JavaSE复习基于（Eclipse工具开发）

JavaSE复习

个人学习笔记

一、Java数据类型：基本数据类型和引用数据类型？

package com.gyzy.JavaIntroView;
/*
 * 1、数据类型：基本数据类型和引用数据类型
 */
public class Demo1_数据类型 {
	//IDE（Integrated Development Environment）集成开发环境
	//Eclipse集成开发工具的常用快捷键
	//1、代码提示完成助手：alt+/（默认）
	//2、复制一行或者多行代码：ctrl+alt+↑或者↓
	//3、移动一行或者多行代码：alt+↑或者↓
	//4、删除一行或者多行代码：ctrl+shift+delete
	//5、选中一行或者某一部分代码：ctrl+shift+ ←或者→
	//6、注释一行代码：ctrl+/
	//7、取消已注释的一行代码：ctrl+/
	//8、注释多行代码：ctrl+shift+/
	//9、取消已注释的多行代码：ctrl+shift+\
	
	//注释：
	//单行注释：//
	//多行注释：/*......*/
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//1、基本数据类型/原生数据类型：
		//Java有8种基本数据类型
		//整数类型：byte(1)、short(2)、int(4)、long(8)
		//小数类型: float(4)、double(8)
		//布尔类型：boolean(1)
		//字符类型: char(2)
		byte a = 127;//byte类型的存储范围：-128-127
		boolean b = true;//true/false
		char c = 'A';
		short  d = 20;
		int e = 30;
		long f = 80;
		float g = 12.8f;
		double h = 128.9;  //小数默认是double类型
		
		double hh = 120;   //自动完成：低精度类型->高精度
		int ff = (int)125.6;    //手动完成：高精度->低精度
		//2、引用类型：类、接口、枚举、数组、String
		//Java种8种封装类型(8种基本数据类型所对应的引用类型)
		//Byte、Boolean、Character、Short、Integer、Float、Long、Double
		Dog dog1;//声明一个引用引用类型的变量，在这里dog1是一个引用变量，可以引用一个Dog类型的对象
		dog1 = new Dog();//使用new关键字给dog1对象真正分配了对象的内存
		dog1.age = 5;
		dog1.breed = "柴犬";
		dog1.name = "小花";
		
		Dog dog2;
		dog2 = dog1;//引用类型赋值，是将自己的引用给了对方，结果就是dog1和dog2引用同一个对象
		//==和equals
		System.out.println(dog1==dog2);//true,两个对象之间的比较（是否指向同一个地址）
		System.out.println(dog1.equals(dog2));//true,两个对象之间内容的比较（两个对象的数据是否相同）
		
		Dog dog3 = new Dog();
		dog3.age = dog1.age;
		dog3.breed = dog1.breed;
		dog3.name = dog1.name;
//		dog3 = dog1;
		System.out.println(dog1==dog3);//false
		System.out.println(dog3.equals(dog1));//false
		
		//基本类型赋值
		int x = 10;
		int y = x;//基本类型赋值:将自己得值复制给对方
		
		System.out.println("y:"+y);
		dog1.age+=1;//dog1.age = dog1.age+1;
		System.out.println("dog1.age:"+dog1.age);
	}

}

二、传递参数：基本类型参数和引用类型的参数

package com.gyzy.JavaIntroView;
/*
 * 2、传递参数：基本类型参数和引用类型的参数
 */
public class Demo2_传递参数 {
	//方法的命名：惯例使用驼峰式，第一单词全部小写，后面每一个单词首字母大写
	//动词+名词说明方法实现什么功能
	
	//基本类型参数
	public static void changeValue(int x){
		x+=10;//x=x+10;
		System.out.println("参数的值是："+x);
	}
	//引用类型的参数
	public static void changeDogAge(Dog dog){
		dog.age+=5;//dog.age = dog.age+5;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//同一个类中，如果一个静态方法想直接调用另外一个方法，那么该方法一定也是静态的
		int a = 100;
		changeValue(a);//方法定义中的参数是形式参数且是局部变量，方法执行结束，该参数自动被Java的垃圾回收机制回收掉
		System.out.println("a的值："+a);//100
		
		Dog dog1 = new Dog();
		dog1.age = 5;//age是全局变量
		dog1.breed = "柴犬";
		dog1.name = "旺财";
		changeDogAge(dog1);
		System.out.println("狗的年龄是："+dog1.age);
	}

}

##三、继承：在Java中的继承是单一继承(一个类只能继承一个父类)
代码如下（示例）：

package com.gyzy.JavaIntroView;
/*
 * 3、继承：在Java中的继承是单一继承(一个类只能继承一个父类)
 * 面向对象编程的四大特性：封装、继承、多态、抽象
 */
//实体类：Student是父类
class Student{
	//成员变量
	String stu_ID;
	String name;
	int age;
	//成员方法
	public void display(){
		System.out.println("显示学生的信息");
		System.out.println("学号:"+stu_ID);
		System.out.println("姓名:"+name);
		System.out.println("年龄:"+age);
	}	
}
//继承:实现了代码的复用性
class LocalStudent extends Student{//本地学生
	//访问控制修饰符
	//public:任何其他类都可以访问该成员,不管类是否和那个类同包
	//private:任何其他类都不可以访问该成员，只能自己这个类访问
	//protected:任何同包下的类还有子类可以访问该成员，子类不同包也可以
	//不写(默认default):同包下的类可以访问该成员
	
	String status;//身份：团员、党员、群众
	
	
	//标注/注解(annotation)：用于说明方法或者类或者变量的特征
	
	//方法的重写/方法覆盖：重新定义继承的方法，子类的定义覆盖父类的定义
	//注意：方法的重写中，子类的方法的访问权限不能低于父类方法的访问权限
	@Override  //重写/覆盖
	public void display() {
		// TODO Auto-generated method stub
		super.display();//在子类中可以使用super关键字访问父类成员
		System.out.println("身份："+status);
	}	
}
//一个类可以被多个类继承，但是不能同时被继承
class OverseasStudent extends Student{//留学生
	String nationality;//国籍
	@Override
	public void display() {
		// TODO Auto-generated method stub
		super.display();
		System.out.println("国籍："+nationality);
	}
}
//测试类
public class Demo3_继承 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		LocalStudent localStudent = new LocalStudent();
		localStudent.stu_ID = "s0001";
		localStudent.name = "Frank";
		localStudent.age = 21;
		localStudent.status="党员";
		localStudent.display();
		
		
		OverseasStudent overseasStudent = new OverseasStudent();
		overseasStudent.stu_ID = "s0002";
		overseasStudent.name = "Lucy";
		overseasStudent.age = 22;
		overseasStudent.nationality = "美国";
		overseasStudent.display();
		
		//Object类是所有类的基类(父类),也就是默认所有类已经继承自Object类
		
		//父类类型的引用变量指向不同子类的对象，就形成了多态
		Student student = new LocalStudent();
				student.display();//方法的重写就形成了动态的多态
		        student = new OverseasStudent();
		        student.display();
	}

}

##四、抽象类 abstract class

package com.gyzy.JavaIntroView;
/*
 * 4、抽象类 abstract class
 * <br>抽象类：包含抽象方法的类
 * <br>抽象类是半抽象的，既可以包含抽象方法，也包含普通的方法
 * <br>抽象类存在的目的是作为一个模板类，被其他类继承
 * <br>一个类继承自抽象类，需要实现继承的所有的抽象方法，除非该类也是抽象的
 */

abstract class Animal{
	String color;
	int age;
	//1、实现了的方法：有方法体的方法(带大括号的)
	public void move(){
		System.out.println("动物可以移动！");
	}
	//2、未实现的方法：没有方法体，只有方法的声明(签名),就是抽象方法
	public abstract void eat();//方法声明
}
class Cat extends Animal{
	String breed;//品种

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("猫吃鱼肉!");
	}	
}
class Pig extends Animal{
	
	public void zhuangShu(){
		System.out.println("猪撞树！！");
	}
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("猪吃饲料！！！");
	}	
}
public class Demo4_抽象类 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//实例化：创建对象的过程，一个对象就是类的一个实例
		//Animal a = new Animal(); //抽象类不能直接实例化
		Cat c = new Cat();
		c.eat();
		Pig p = new Pig();
		p.eat();
		p.zhuangShu();
		//父类类型的引用变量指向不同子类的对象，就形成了多态
		Animal a1 = new Cat();
		       a1 = new Pig();
	}

}

五、接口-interface

package com.gyzy.JavaIntroView;
/**
 * @author:Daly
 * @Date:2021年1月20日
 * @Version:
 * @Description:接口
 * 5、接口-interface
 * <br>如果一个类中的所有方法全部抽象，可以考虑接口
 * <br>接口相当于一个完全抽象的类
 * <br>接口中的方法全部默认是public abstract 
 * <br>接口用于定于规范/标准，但是不提供实现，由各个类提供方法的实现；
 * <br>接口中不能有构造方法
 * <br>接口中的变量默认全部是public static final,也就是静态常量；
 * <br>一个类实现接口，需要实现接口中所有的方法（所有的方法都是抽象的）
 */
//定义接口:接口是在程序设计阶段
interface Shape{
	double PI = 3.14;//常量名全部大写
	//计算面积
	void calculateArea();
	//计算周长
	public void calculateCircumference();
	
}
//画图：圆-Circle,正方形-Square,长方形-Rectangle，三角形......
//类和接口，类实现接口，相当于继承
class Circle implements Shape{
	double radius;

	@Override
	public void calculateArea() {
		// TODO Auto-generated method stub
		System.out.println("圆的面积："+PI*radius*radius);
	}

	@Override
	public void calculateCircumference() {
		// TODO Auto-generated method stub
		System.out.println("圆的周长："+2*PI*radius);
	}	
}
class Square implements Shape{
	double width;
	@Override
	public void calculateArea() {
		// TODO Auto-generated method stub
		System.out.println("正方形的面积："+width*width);
	}

	@Override
	public void calculateCircumference() {
		// TODO Auto-generated method stub
		System.out.println("正方形的周长："+2*(width+width));
	}	
}
class Rectangle implements Shape{
	double width;
	double height;
	@Override
	public void calculateArea() {
		// TODO Auto-generated method stub
		System.out.println("长方形的面积："+width*height);
	}

	@Override
	public void calculateCircumference() {
		// TODO Auto-generated method stub
		System.out.println("长方形的周长："+2*(width+height));
	}	
}
public class Demo5_接口 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//使用接口
		//	Shape s = new Shape();接口不能直接实例化
		Circle c = new Circle();
		c.radius = 2.5;
		c.calculateArea();
		c.calculateCircumference();
		
		Rectangle r = new Rectangle();
		r.height = 2.3;
		r.width = 3.6;
		r.calculateArea();
		r.calculateCircumference();
		
		//多态性的体现：一个接口类型可以指向不同的实现类
		Shape s1 = new Circle();//可以通过接口的实现类实例化接口
		      s1 = new Rectangle();
		      s1 = new Square();
	}

}

##六、继承总结

package com.gyzy.JavaIntroView;
/**
 * @author:Daly
 * @Date:2021年1月20日
 * @Version:
 * @Description:
 * 6、继承总结
 */
//类和类，单一继承
class A{
	int a;
	void methodA(){}
}
class B{
	int b;
	void methodB(){}
}
class C extends A{
	int c;
	void methodC(){}
}

//class D extends A,B{  java不支持类的多根继承，一个类只能继承一个父类 }
//C和A   A是C的父类，C是A的子类/派生类
//E和A   A是E的父类，E是A的派生类
class E extends C{}

interface AA{
	void methodAA();
}
interface BB{
	void methodBB();
}
interface CC{
	void methodCC();
}
//接口和接口可以继承，java支持接口的多根继承，接口的多继承弥补了java单一继承的不足
interface DD extends AA,BB,CC{
	void methodDD();
}
//类和类，类和接口
class F extends A implements AA,BB,CC{

	@Override
	public void methodCC() {
		// TODO Auto-generated method stub	
	}

	@Override
	public void methodBB() {
		// TODO Auto-generated method stub	
	}
	@Override
	public void methodAA() {
		// TODO Auto-generated method stub	
	}	
}
interface 路栖动物行为{
	void crawl();
}
interface 水栖动物行为{
	void swim();
}
//一个类可以同时继承自另外一个类和实现多个接口
class Frog extends Animal implements 路栖动物行为,水栖动物行为{

	@Override
	public void swim() {
		// TODO Auto-generated method stub	
	}
	@Override
	public void crawl() {
		// TODO Auto-generated method stub	
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
	}	
}
public class Demo6_继承总结 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		AA aa = new F();
		BB bb = new F();
		//CC cc = new A();//A并没有直接实现CC，A仅仅只是用于被F继承，F只是继承了A中的属性和方法，A并没有帮助F实现CC的抽象方法
		
		//类和类:继承，一个类可以继承自一个父类；
		//接口和接口：继承，一个接口可以继承多个接口；
		//类和接口:实现，一个类可以实现多个接口	
		
	}

}

##七、静态成员(static members)和非静态成员(non-static)

package com.gyzy.JavaIntroView;
/**
 * @author:Daly
 * @Date:2021年1月20日
 * @Version:
 * @Description:
 * 7、静态成员(static members)和非静态成员(non-static)
 */
//实体类
class Circle1{
	//构造函数-constructor
	//构造函数是一种特殊的方法，没有返回值，方法名称与类名完全相同
	//创建对象的时候自动被调用，构造函数每创建一个对象就被调用一次
	
	//构造函数的作用：用于执行一些初始化成员变量以及执行一些初始化的操作
	public Circle1(){
		System.out.println("实例化了一个圆");
	}
	
	//静态代码块：用于执行一些初始化的操作，但是和构造函数不同
	//静态代码块在使用该类的过程中只执行一次，早于构造函数等的执行
	//静态代码是由虚拟机自动调用，不需要人为手动调用
	static{
		System.out.println("执行静态代码块~~~~~~~~~~~~~~~~~~~~~~~");
	}
	
	//非静态，如果一个成员是属于对象，定义为非静态
	//非静态成员每创建一个对象，就要分配内存
	double r;
	
	//静态，如果一个成员是属于类，定义为静态
	//静态成员在使用类的整个过程中，内存只分配一次
	//对该类所有的对象而言，都共享这一份静态的成员变量
	static double PI=3.14;
	//如果一个方法操作了非静态成员，只能定义为非静态方法
	//非静态的成员方法，既可以操作非静态的成员，也可以操作静态的成员
	public void showR(){
		System.out.println("圆的半径："+r);
		System.out.println("圆周率："+PI);
	}
	//如果一个方法的执行和具体对象无关，比如没有操作非静态成员，可以设置为静态的方法
	//静态成员方法，只能操作静态成员，不能操作非静态成员
	public static void showPI(){
		System.out.println("圆周率："+PI);
//		System.out.println("圆的半径："+r);
	}	
}
//测试类
public class Demo7_静态和非静态 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//使用静态成员
		//静态成员可以直接通过类名访问，也就是可以不创建任何对象，直接访问
		System.out.println(Circle1.PI);
		Circle1.showPI();//静态成员方法可以直接通过类名调用，但是非静态成员只能通过对象调用
		
		//使用非静态成员
		Circle1 c1 = new Circle1();
		c1.r = 2.5;//非静态成员必须通过对象访问，要先创建对象才能访问非静态成员
		c1.showR();
		
		System.out.println(c1.PI);//可以使用类对象访问静态成员，但是不推荐
		
		Circle1 c2 = new Circle1();
		c2.r = 5;//非静态成员必须通过对象访问，要先创建对象才能访问非静态成员
		c2.showR();
		

	}

}

##八、构造函数(constructor)和多态(polymorphism)

package com.gyzy.JavaIntroView;
/**
 *@author:Daly
 * @Date:2021年1月20日
 * @Version:
 * @Description:
 * 8、构造函数(constructor)和多态(polymorphism)
 */
class Calculator{
	//Java是支持方法的多态，一个方法可以定义多次，但是参数不同
	//1、可以是参数的个数不同
	//2、参数的类型可以不同
	//3、参数的顺序可以不同
	
	//方法的重载：在同一个作用域中，方法名称完全相同，参数不同就构成了方法的重载
	public int add(int a,int b){
		return a+b;
	}
	public int add(int a,int b,int c){
		return a+b+c;
	}
	public double add(float a,double b){
		return a+b;
	}
	public double add(double a,double b){
		return a+b;
	}
}
class Dog1{
	String name;
	String breed;
	int age;
	//每个类默认有一个不带参数的构造方法，那么一旦手动创建了构造函数，那么这个无参数的默认的构造函数自动消失
	
	//构造函数-constructor
	//构造函数是一种特殊的方法，没有返回值，方法名称与类名完全相同
	//创建对象的时候自动被调用，构造函数每创建一个对象就被调用一次
	
	//构造函数的作用：用于执行一些初始化成员变量以及执行一些初始化的操作
	//如果自己定义了构造函数，那么默认的就自动消失了
	public Dog1(){
		name = "小花狗";
		breed = "哈士奇";
		age = 5;
	}
	public Dog1(String name){
		this.name = name;//this表示当前对象，可以使用它区*部变量和全局变量
	}
	public Dog1(String name,String breed){
		this.name = name;
		this.breed = breed;
	}
	public Dog1(String name,String breed,int age){
		this.name = name;
		this.breed = breed;
		this.age = age;
	}
	//构造方法是方法重载的特殊体现
	public void display(){
		System.out.println("----------------------打印狗狗的信息-------------------------------------");
		System.out.println("狗名："+name);
		System.out.println("品种："+breed);
		System.out.println("年龄："+age);
	}
}
public class Demo8_构造函数和多态 {
	public static void main(String[] args) {
		Calculator cal = new Calculator();
		//方法的重载构成了静态的多态
		cal.add(20.5, 30);
		cal.add(10, 20,30);
		
		//构造函数形成了方法的重载，从而形成了静态的多态
		Dog1 d1 = new Dog1();
		d1.display();
		Dog1 d2 = new Dog1("柯基");
		d2.display();
		Dog1 d3 = new Dog1("哈哈","拉布拉多");
		d3.display();
		Dog1 d4 = new Dog1("单身狗","柴犬",5);
		d4.display();
		
	}

}