Java学习笔记1

类和对象：

传参：
（1）变量有两种类型：基本类型和类类型。
	参数也是变量，所以传参分为：基本类型传参，类类型传参。
（2）基本类型传参：
	在方法内，无法修改方法外的基本类型参数。
	
（3）引用与=
	如果一个变量是基本类型，比如 int hp = 50;我们就直接管hp叫变量。
	=表示赋值的意思。
	如果一个变量是类类型，比如Hero h = new Hero();就叫h为引用
	=表示指向的意思。这句话的意思就是引用h，指向一个Hero对象。
（4）类类型传参
	类类型又叫引用，

包：
（1）把比较接近的类，规划在同一个包下
（2）使用其他包下的类，必须import

成员变量中的四种修饰符：
a：private
b: protected
c: public
d: package(不写)
(1)：类和类之间的关系有如下几种:
	以Hero为例
	自身：指的是Hero自己
	同包子类：ADHero这个类是Hero的子类，并且和Hero处于同一个包下
	不同包子类：Support这个类是Hero的子类，但是在另一个包下
	同包类： GiantDragon 这个类和Hero是同一个包，但是彼此没有继承关系
	其他类：Item这个类，在不同包，也没有继承关系的类


（2)使用private修饰属性：只有自身可以访问，其他类都不能访问和继承，子类也不能继承。
（3）使用protected修饰属性：
	自己可以访问
	同包子类可以继承，不同包子类可以继承，
	同包类可以访问，不同包类不能访问。
（4）pulic修饰属性：
	自己可以访问，
	同包子类和不同包子类都可以继承，
	同包类和不同包类可以访问。

接口与继承：
1：多态
（1）：操作符的多态
+ 可以作为算术运算符，也可以作为字符串连接符。

		public class Hero {
				public String name;
				protected float hp;
				public static void main(String[] args) {
    				int i = 5;
    				int j = 6;
    				int k = i+j; //如果+号两侧都是整型，那么+代表 数字相加
    				System.out.println(k);
    				int a = 5;
    				String b = "5";
   					String c = a+b; //如果+号两侧，任意一个是字符串，那么+代表字符串连接
   					System.out.println(c);
					}   
			}
	（2）：类的多态
		a：什么是多态？
		一种事物存在多种形态，男人和女人都是人，人可以分为男人和女人。
		对于java中类的多态来说--都是同一个类型，调用同一个方法，呈现的是不同的状态。
		
		b：类的多态的使用条件：
			父类/接口的引用指向子类对象。
			调用的方法有重写。

2：java中方法的隐藏
	（1）：什么是方法的隐藏？
	与重写类似，重写是子类覆盖父类的对象方法。
	隐藏就是子类覆盖父类的类方法。

	（2）：对于一个父类，定义如下：
	public class Hero {
			public String name;
			protected float hp;

			//类方法，静态方法
			//通过类就可以直接调用
			public static void battleWin(){
    			System.out.println("hero battle win");
			 }
		}
		
		对于一个子类，定义如下：
	public class ADHero extends Hero implements AD{

			@Override
			public void physicAttack() {
    			System.out.println("进行物理攻击");
				}
			//隐藏父类的battleWin方法
		 public static void battleWin(){
    			System.out.println("ad hero battle win");
				}    
			public static void main(String[] args) {
    			Hero.battleWin();
    			ADHero.battleWin();
				}

		}

3：java中final修饰符的使用
--final修饰类，方法，基本类型变量，引用的时候分别有不同的意思。
	（1）：final修饰类
		如果一个父类被修饰成final的时候，表示该父类不能被继承
	（2）：final修饰方法
		父类中方法被final修饰，该方法不能被重写。
	（3）：final修饰基本类型变量
		final修饰的基本类型变量表示只能有一次赋值的机会，一但赋值，不能再改变。
	（4）：final修饰引用
		当一个类的引用被final修饰时，表示该引用只有一次指向对象的机会。

4：java中抽象类
	（1）：
	在一个类中声明一个方法，这个方法没有实现体，是一个“空”方法
	这样的方法就是抽象方法，使用修饰符"abstract"
	当一个类中有抽象方法时，该类必须声明为抽象类。
	抽象类不可以被实例化，只有被实体类继承后，抽象类才会有作用。
	（2）子类必须重写抽象父类中的所有方法。
	若不都重写，子类也必须声明为抽象类。
	（3）抽象类和接口的区别：
		区别1：
		子类只能继承一个抽象类，而可以实现多个接口。

		区别2：
		抽象类可以定义：
		public，protected，package，private
		静态和非静态属性。
		final和非final属性。
		
		接口中申明的属性，只能是：
		public，静态，final

5：java中内部类
	（1）非静态内部类
		非静态内部类可以直接在一个类里面定义。
		访问语法为：new 外部类().new 内部类()
		EG：
		public class Hero {
			private String name; // 姓名

			float hp; // 血量

			float armor; // 护甲

			int moveSpeed; // 移动速度

			// 非静态内部类，只有一个外部类对象存在的时候，才有意义
			// 战斗成绩只有在一个英雄对象存在的时候才有意义
			class BattleScore {
    		int kill;
    		int die;
    		int assit;
    		public void legendary() {
        			if (kill >= 8)
            			System.out.println(name + "超神！");
        			else
            			System.out.println(name + "尚未超神！");
    				}
				}
			public static void main(String[] args) {
    			Hero garen = new Hero();
    			garen.name = "盖伦";
    			// 实例化内部类
    			// BattleScore对象只有在一个英雄对象存在的时候才有意义
    			// 所以其实例化必须建立在一个外部类对象的基础之上
    			BattleScore score = garen.new BattleScore();
    			score.kill = 9;
    			score.legendary();
				}
		}
	（2）静态内部类
		在一个类里面声明一个静态内部类
		比如敌方水晶，当敌方水晶没有血的时候，己方所有英雄都取得胜利，而不只是某一个具体的英雄取得胜利。
		与非静态内部类不同，（静态内部类水晶类的实例化 不需要一个外部类的实例为基础，可以直接实例化）
		语法：new 外部类.静态内部类();
		因为没有一个外部类的实例，所以在静态内部类里面不可以访问外部类的实例属性和方法
		除了可以访问外部类的私有静态成员外，静态内部类和普通类没什么大的区别
	（3）匿名类
		匿名类指的是在声明一个类的同时实例化它，使代码更加简洁精练
		通常情况下，要使用一个接口或者抽象类，都必须创建一个子类
		有的时候，为了快速使用，直接实例化一个抽象类，并“当场”实现其抽象方法。
		既然实现了抽象方法，那么就是一个新的类，只是这个类，没有命名。
		这样的类，叫做匿名类
		EG：
		public abstract class Hero {
				String name; //姓名          
				float hp; //血量          
				float armor; //护甲          
				int moveSpeed; //移动速度      
				public abstract void attack();      
				public static void main(String[] args) {
              			ADHero adh=new ADHero();
    				//通过打印adh，可以看到adh这个对象属于ADHero类
    				adh.attack();
    				System.out.println(adh);          
    				Hero h = new Hero(){
       			 	//当场实现attack方法
        				public void attack() {
            				System.out.println("新的进攻手段");
        					}
    				};
    				h.attack();
    				//通过打印h，可以看到h这个对象属于Hero$1这么一个系统自动分配的类名          
    				System.out.println(h);
					}
			}
	（4）本地类
		本地类可以理解为有名字的匿名类
		内部类与匿名类不一样的是，内部类必须声明在成员的位置，即与属性和方法平等的位置。
		本地类和匿名类一样，直接声明在代码块里面，可以是主方法，for循环里等等地方

6：Java中的默认方法
	（1）什么是默认方法：
		接口也可以直接提供具体方法了，不像以前，只能提供抽象方法。
		定义默认方法的关键字为--default
	（2）为什么会有默认方法：
		假设没有默认方法这种机制，那么如果要为Mortal（定义的一个接口）增加一个新的方法revive,那么所有实现了Mortal接口的类，都需要做改动。
		但是引入了默认方法后，原来的类，不需要做任何改动，并且还能得到这个默认方法
		通过这种手段，就能够很好的扩展新的类，并且做到不影响原来的类

7：Java中封装类
	所有的基本类型，都有类类型，比如int对应的类是Integer，这种类就是封装类。