Java1

对象引用

Light lt=new Light()； //实例化
1.new Light：在堆里创建一个Light类对象。
2.Light后括号()：对象创建后，立即调用Light类构造函数，并对刚生成对象初始化。
3.It：对象引用变量，Light类。It存的是对象地址。
4.=：lt指向新创对象。

作用域

局部变量：方法内；必须赋初始值；不同方法可有同名局部变量；优先级高(就近原则)。
成员变量：即实例变量/属性，整个类内；可不赋初始值。

构造方法

创建对象并初始化对象的方法。无返回值。
注：构造方法的形参和成员变量不是一个东西。

访问权限

public：全都
protected：子类、同一包、同一类
default：同一包、同一类
private：同一类

继承：is-a

1.单继承：父类/基类——子类/派生类
2.代码复用：子类继承父类所有非private属性方法。class 子类 extends 父类{}
3.Override：返回值类型、方法名、参数类型和个数与父类相同。
4.初始化顺序：先父后子；先初始化对象中属性，再构造方法。

[图片来源：慕课网]
5.final
修饰类：不许被继承
修饰方法：不许被重写
修饰变量：仅能赋一次值。变为常量
修饰属性：二选一：①属性不能隐式初始化。必须有值；②构造方法中赋值。
6.调用父类属性/方法：super。
子类构造方法运行时自动调用父类构造方法。隐式调用。

public Animal(){  //Animal为父类
	void eat(){
	System.out.println("Food||");
}

public Dog(){    //Dog为子类
	//super();    //如果显示必须放第一行
	void eat(){
	System.out.println("Food-Bone");
}

运行结果：Food || Food-Bone
当子类未显示调用且父类没有无参构造方法，会报错。
7.Object是所有类父类。未标注的都是继承于Object。
①System.out.println(对象);返回对象地址哈希码：包.类@地址。
用toString()重写对象可返回类+属性文本值(即String形式)。

@Override
public String toString() {
  return "Dog [age=" + age + "]";
 }

②equals()：比较对象的引用是否指向同一地址。返回值布尔类型。
需要比较值是否一样时：重写。Source里有。

@Override
 public boolean equals(Object obj) {
  if (this == obj)   //引用地址是否相同
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())   //两对象类型是否相同
   return false;
  Dog other = (Dog) obj;    //Object类的obj属性类型换成Dog类属性类型
  if (age != other.age) 
   return false;
  return true;
 }

封装

this：可区别局部变量与成员变量。调用变量；调用方法。

int n;
public void f(int n){
	this.n=n;
}

int n;
public void f(int nn){
 n=nn;
}

多态性：

1.引用多态：父类引用指向奔本类/子类多态。子不能指父。

Animal obj=new Dog();

方法多态：本类创本类对象指向本类方法；父类创子类对象调用子类重写/继承方法，不能调子类多独有方法。(只有方法是，属性不是。)
2.引用类型转换：向上/隐式/自动转换；向下/强制转换
检验安全性：要转换对象 instanceof 转换成的类
向上：Animal obj=dog;强调赋值？

抽象类

1.限制子类必须实现某些方法，不关注细节。
2.多个具有相同特征的类中抽象出抽象类，以之作为子类模板。
使用：1.abstract定义类和方法，只需声明不需实现。
2.抽象类可以包含非抽象方法。
3.抽象类有构造方法，只是不能实例化。接口根本没有构造方法，不能实例化。
4.抽象类不能直接创建，可以定义引用变量指向子类对象。

public abstract class Animal{
	public abstract void eat();
}
public Dog extends Animal{
	public eat(){
	System.out.println("Bone");
}

public class Initial{
	Animal ani=new Dog();
	ani.eat();
}

接口：has-a。全局常量+公共抽象方法。

1.类是一种具体实现体，而接口是定义了类必须遵守的规范：限制类必须实现某些方法，不关心实现。
2.多继承

修饰符 [abstract] interface 接口名 [extends 父接口1，2，……]{
	常量定义
	抽象方法定义[abstract同上可以省略，自动添加。]
}
public interface Ipicture{
	public void draw();
}

修饰符通常用public，不能用private，protected。用来被继承、被实现。
接口名字通常首字母是I。
3.定义：
属性是常量。public/static/final会自动添加。
方法是抽象方法。abstract会自动添加。
4.一个类可接一/多个接口。

修饰符 class 类名 extends 父类 implements 接口1，2，……{//extends和implements位置不能换！
	继承抽象类：实现继承的抽象方法+接口的抽象方法。
}

5.接口可以描述两个不同类型的功能特性。

6.匿名内部类

接口 接口名=new 接口(){
	接口里的方法(){}
	}；
调用。
Ipicture i=new Ipicture(){
	public void draw(){
	System.out.println("Drawing.");
};  //注意分号！！！！！！
i.draw();

或：直接调用

new Ipicture(){
public void draw(){
 System.out.println("Drawing.");
}.draw();

内部类：

内部类隐藏在外部类之内，同一包中其他类不能访问该类。
内部类可直接使用外部类所有方法；反过来外部类不能。
内部类功能外部类也能实现，只是内部类更方便。
Outer o=new Outer(); //文件：Outer.class
Inner i=o.new inner(); //文件：Outer$Inner.class
若外部类和内部类有相同的成员变量或方法，内部类默认访问自己的成员变量或方法。若要访问外部类成员变量用 this 。

匿名内部类

没名字的内部类。不关注类名，只关注实现。仅在使用时定义。

方法内部类

定义在外部类方法中。仅在该方法内部可见。不能使用访问控制符和static修饰符。

方法

一个方法只能由一个对象调用。静态方法不需对象直接被类调用。

名字可视性

反转自己Internet域名。e.g. 域名Sheldon.net，ti工具库域名：net.sheldon.utility.ti

static静态类

内存固定；方法和域不需要绑捆绑对象。
引用：类.变量/方法；对象.变量/方法。
初始化块：构造器的补充，不接收任何参数，定义所有对象共有的属性、方法等。
静态初始化块：1.只在类加载时执行，且只执行一次。2.只能给静态变量赋值，不能初始化普通的成员变量。3.最先被执行，然后执行普通初始化块，最后才执行构造方法。
执行顺序：静态代码块>构造代码块>构造函数。
注：1.静态方法中，可直接调用同类中的静态成员，非静态成员、方法不可直接调用，只能通过对象调用。
普通成员方法中，同类的非静态变量和静态变量均可直接访问。2.其他类的静态方法有public且在同一包中，可直接调用。【？

static静态内部类

1.访问外部类非静态：new 外部类().成员
2.外部类静态与内部类重名，访问外部类静态：类名.静态成员
不重名：直接访问
3.创建对象：不需外部类对象，直接创建

读取输入

import java.util.Scanner;
Scanner input;
int grade=input.nextInt(); //根据类别选

Arrays类操作数组

import java.util.Arrays；
Arrays.sort(数组名)；//升序
System.out.println(Arrays.toString(数组名))；
//元素转换为字符串。效果：[xx，xx，xx]

foreach

for(类型 变量：遍历对象) {System.out.println(变量)；}
eg：

int[] score=new int[]{12,14,16,18};
for(int grade：score)
{System.out.println(grade)；}

重载

判断依据：1.必须是在同一个类中。2.方法名相同。3.方法参数的个数、顺序或类型不同。4.与方法的修饰符或返回值无关

其它

public void calcAvg(int num1,int num2){	
	double avg=(num1+num2)/2.0;
	//或：double avg=(double)(...)/2。否则会报错    
	System.out.println(avg);
}

public void calcAvg(double num1,double num2){ 
	double avg=(num1+num2)/2；//或2.0
	System.out.println(avg);
}

2."=="：对基本数据类型数据：比较值。
对非基本数据类型数据：比较指向所指向对象的地址：两个对象是否是同一个引用，即指针或引用是否相同。
equals()：不能用于基本数据类型的变量。
未重写：比较引用变量指向的对象地址；
重写了：比较指向的对象值是否相同。

3.getClass()：得到类对象。就是有啥类。
new得到的是类的对象。