JavaSE

JavaSE:Day1:
简单知识点概要：
1：关于private关键字
2：关于this和super的使用
3：关于final关键字的使用
4:构造方法
5：静态static
6：继承
7：抽象
8：接口的实现
9:多态
10：成员内部类
11：扩展知识点代码块

一：关于private关键字：

概念：表示为定义为私有的，在成员方法中定义了private关键字，只能在本类中直接使用，不能在其他类中直接被使用，只能用private常用的方法(get/set)来调用：
扩展：在后面的反射也可以直接获取到变量的值；
set用来给定义的变量进行赋值值；
get用来获取到定义变量的值；

	class Test{
		private String name;
			public void  setname(String name){
				this.name=name;
			}
			public String getname(){
				return  name;
		}
}

在主方法中进行使用private修饰的变量：

	class Test1{
		public static void main(String []args){
			Test  t=new  Test();
			t.setname("小王");
			System.out.println(t.getname);   //小王
			
			}
		}

二：关于this和super的使用：

this:
	概述：表示的是当前类；
super:
	概述：表示为父类

父类
class Fu{
	String name="父亲";
	public void method(){
		System.out.println(这是父类中的method1);
	}
}

子类
class Zi extends Fu{
	String name="儿子";
	public void method(){
		//这是在子类中的name:儿子
		System.out.println("这是在子类中的name:"+this.name);
		System.out.println("这是在父类中的name:"+super.name)
		//这是在父类中的name:父亲
		System.out.println("这是一个子类中的子类");
	}
}

主类：
class Test{
	public static void  main( String []args){
		Zi z=new Zi();
		z.method();
		//输出结果：
		//这是在子类中的name:儿子
		//这是在父类中的name:父亲
		//这是一个子类中的子类
		}
}

三：关于final关键字的使用：

概述：表示为final修饰的，被该关键字修饰的将可看作为一个常量，变量的值不可被修改.

//在本类中进行使用
class Test{
//成员变量
	final String name="小王";
	public void method(){
	//局部变量
	final String  age=16;
		//age=17;   无论是在成员变量还是在局部变量都不能修改final的值
		//在本类中可以正常的获取
		//一般在写本类的变量调用的时候是不需要写this的，但是为了更好的理解，所以我还是加上
	System.out.println("获取本类中被final修饰的name:"+this.name);
		//尝试对被final修饰的变量进行重新赋值--->会报错！
		//this.name="小新"; ----->这里就开始爆红了（报错）
				
	}
	
}

//在其他类中进行调用和修改：
class Test1{
	public static void main(String []args){
		//创建Test对象
		Test  t=new Test();
		//t.name="小新"; --->报错:也不能在其他的类中进行修改
	}
}

四：构造方法：

正常类都是有成员方法的：
没有构造方法的类：匿名内部类，内部类，这两种后面会进行介绍

class Test{
	String name;
	int age;
	SDtring sex;
	public void Test(){
		System.out.println("这是一个无参构造");
	}
	public void Test(String name){
		System.out println("这是一个有参构造");
		}
	public void Test(String name,int age,String sex){
		System.out.println("这是一个满参构造");
	}
	
}

class Test1{
	public static void main(String []args){
		//该调用的是无参构造，这里是利用无参构造在堆内存中new出来了一个类对象
		Test  t=new Test();
		//输出结果是：
		//这是一个无参构造
	}
}

五：静态static的使用：

概述：被该关键字修饰的方法 和变量在其他类中使用都不能被直接调用；
调用方式：类名.方法（）；或者是：类名.变量

 class Test{
	static String  name="小王";
	public static void method1(){
		System.out.println("这是被静态static关键字修饰的name:"+name);
	}
}

class Test1{
public static void main(String [] arsg){
	Test t=new Test();//创建了对象，但是也是不能调用Test中的方法和成员变量的
	//String a=t.name;---->直接爆红，提示中也没有该name
	//类名.调用成员变量
	System.out.println(Test.name);
	//调用成员方法
	Test.method1();
	//输出结果：这是被静态Static关键字修饰的name:小王
	}
}

六：继承：

概述：当一个子类继承了父类之后将继承拥有父类的成员方法和成员变量；
注意：（构造方法和私有变量和静态方法不能被继承），一个子类只能同时继承一个父类，但是可以嵌套继承达成概念是的爷父子类的关系

calss Fu{
	static String name="小王";
	String  name1="小新";
	private String name2="小郑";
	int age=18;
	public void Fu(){
		System.out.println("这是Fu类中的无参构造");
	}
	public static void method(){
		System.out.println("这是静态成员方法！");
	}
	public void method1(){
		System.out.println("这是成员变量");
	}
	public void method2(String name){
		System.out.println("这是一个在Fu类中的method2中的成员方法:"+name);
	}
}

class Zi{
	int age=10;
	public void Zi(){
	//这里是调用了父类中的构造方法，如果是有参的，那么就直接在括号中填写顺序相同,和个数相同，参数类型相同的值；
		Super();
	//这里使用的age是来自于子类中的
		System.out.println("这是Zi类中的构造方法："+age);
		//如果想要使用来自与父类中的age
		System.out.println("这是Zi类中调用Fu类中的成员变量age:"+super.age);
	}
	public static void Zimethod1(){
		System.out.println("这是子类中的静态方法");
	}
	//如果在继承或者是在实现的关系下，那么在子类中复写了父类中的方法并且参数列表相同，那么可以看作是子类重写了父类中的method2方法
	@Override      //这是判断是否是重写了父类中的方法
	public void method2(String name){
		System.out.println("这是一个在Zi类中的method2中的成员方法"+name);
	}
}

class Test{
	public static void main(String []args){
		Zi zi=new Zi();
		zi.method1();
		zi.method2("小王");
		//输出结果
		//这是Fu类中的无参构造
		//这是Zi类中的构造方法：10
		//这是Zi类中调用Fu类中的成员变量age:18
		//这是成员变量
		//这是一个在Zi类中的method2中的成员方法小王
		}
}

七：抽象：

抽象概述：是指使用abstract关键字修饰的类或者方法，
注意：
1：一个类被abstract关键字修饰的方法一定是抽象类，
2：一个被abstract关键字修饰的类的方法，不一定是抽象方法
3：当抽象类被继承，那么子类一定是要重写里面全部的抽象方法
4:如果是抽象方法是没有代码块的，只能在实现类中填写行为
5：抽象类有构造函数

抽象部分：

class abstract Fu{
	public abstract void method ();
	public void method1(){
		System.out.println("这是在抽象子类中的成员方法");
	}

}

calss Zi extends Fu{
	@Override
	public void method(){
		System.out.println("这是重写父类中的抽象方法");
	}
	public static void method1(){
		System.out.println("这是一个在子类中的静态方法method1");
	}
}

class Test{
	public static void main(String []args){
		Zi zi=new Zi();
		//用类名调用子类中的静态方法
		Zi.method1();
		//类对象调用子类中的成员方法
		zi.method();
		//输出：
		//这是重写父类中的抽象方法
		//这是一个在子类中的静态方法method1
	}
}

八：接口的实现：

概述：接口是类行为的抽象（我们通常是把一个被多个类实行的方法抽取为一个接口），接口，接口中只有，静态方法，和抽象方法，还有默认方法，没有构造方法，一个类可以实现多个接口，一个接口可以继承多个接口
注意：
1：接口中是没有构造方法的
2：接口中只有：常量，抽象方法，静态方法和默认方法 (jdk8),私有方法
接口中成员的访问特点:
接口中的常量: 主要是供接口直接使用
接口中的抽象方法: 供实现类重写的
接口中的默认方法: 供实现类继承调用,或者重写调用
接口中的静态方法: 只供接口直接调用,实现类继承不了
接口中的私有方法: 只能在接口中直接调用,实现类继承不了

//这里定义一个接口：
interface  A{
	//定义一个常量
	static final String name="小新";
	//定义一个默认方法
	public default vodi method(){
		System.out.println("这是一个默认方法");
	}
	//定义一个静态方法
	public static void method1(){
		System.out.println("这是一个静态方法");
	}
	//定义一个抽象类
	public void eat();
	//定义一个私有方法
	private void method2(){
		System.out.println("这是一个私有方法");
	}
}

class Cat implements A{
	@Override
	public void eat(){
		System.out.println("猫吃鱼");
	}
}

```java
class Test{
public static void main(String []args){
	Cat cat=new Cat();
	cat.eat();
	//输出：
	//猫吃鱼
	}
}

九：多态部分：

多态是继封装、继承之后，面向对象的第三大特性；
注意：如果要进行多态，那么就一定要继承或者是实现

class F{
	public void method(){
		System.out.println("这是一个在F类中的成员方法");
	}
	public static void method1(){
		System.out.println("这是一个在F类中的静态方法");
	}
}

class Zi extends  F{
	public void method(){
		System.out.println("这是一个在Zi类中的成员方法");
	}
	public static void method1(){
		System.out.println("这是一个在Zi类中的静态方法");
	}
	}

class Test{
	public static void main(String []args){
	//对象调用非静态方法，父类编译，子类执行
	//对象调用静态方法，父类编译，父类执行
		F  t=new Zi();
		t.method();
		//这是一个在Zi类中的成员方法
		t.method1();
		//这是一个在F类中的静态方法
	}
}

扩展：向上转型和向下转型
向上转型就是正常的多态

class F{
	public void method(){
		System.out.println("这是一个在F类中的成员方法");
	}
	public static void method1(){
		System.out.println("这是一个在F类中的静态方法");
	}
}

class Zi extends  F{
	public void method(){
		System.out.println("这是一个在Zi类中的成员方法");
	}
	public static void method1(){
		System.out.println("这是一个在Zi类中的静态方法");
	}
	public void look(){
		System.out.println("我是一个指尖玩家");
		}
	}

class Zi2 extends F{
	public void method(){
		System.out.println("这是一个在Zi2类中的成员方法");
	}
	public static void method1(){
		System.out.println("这是一个在Zi2类中的静态方法");
	}
}

class  Test{
	public static void main(String [] args){
		F  t=new Zi()
		//父类的引用指向子类的引用
		Zi  z=(Zi)t;   //向下转型,可以访问子类独有的功能方法
		z.look();
		//输出：
		//我是一个指尖玩家
/***
	扩展
	//在进行下辖转型的时候，最好添加个判断在进行转型
	if (t instanceof Zi ){   //如果可以转型，那么返回为true，否则为false
		Zi  z=(Zi)t; 
	}
	*/
		
	}
}

十：成员内部类：

概述：就是在类中定义一个成员类
注意：内部类访问外部类成员，包括私有成员直接访问
如果外部类访问内部类成员必须要建立内部类对象
外部类调用内部类对象创建格式：
外部类名.内部类名 对象名=new 外部类型.new内部类型

class Test{
	private String name="小王";
	//外部类访问内部类
	public void  method(){
	//因为是在本类中，所以内部类创建对象就行
		Test1  t=new Test1()
		System.out.println(t.name);     //小新
	}
	public class Test1{
		String  name="小新";
		public void method1(){
				//访问外部类的成员变量
			System.out.println(Test.name);   //小王
			//访问内部类的成员变量
			System.out.println(name);  //小新
	}
}
}

class Demo{
	public static void main(String []args){
		Test.Test1  t=new Test().new Test1();
		t.method1();     //调用内部类中的method1
		Sytstem.out.println(t.name);    
		//输出结果：
		//小王
		//小新
		//小新
		Test t1=new Test();
		System.out.println(t1.name);   //小王
		t1.method()   //小新
		}
	
}

十一：代码块：

概述：就是在方法中的花括号中的就是代码块

class Demo{
static{
	System.out.println("这是静态代码块");    //在加载class文件的时候运行
}
{
	System.out.println("这是构造代码块");     //在创建对象的时候运行，比构造方法快
}
public vodi Demo(){
		System.out.println("这是构造方法");
	}

}

class Test{
	public static void main(String []args){
				Demo d=new Demo();
				//输出结果：
				//这是静态代码块
				//这是构造代码快
				//这是构造方法
		}	
}