JAVA 面向对象

Java 大小写敏感 （类大写 方法小写）
文件名和类名必须保持一致

一、基本数据类型分两类

（1）八大基本数据类型：

1.整数 (byte 占1字节: -128 – 127
short 占2字节: -32768 – 32767
int 占4字节: -2147483648 --2147483647
long 占8字节: -9223372036854775808 – 9223372036854775807
)
byte num1 = 10; short num2 = 100; int num1 = 1000; long num1 = 30L;

2.浮点数（float 占4个字节 double 占8个字节）
float num5 = 20.3F; double num6 = 20.3222222222;

3.字符 （char 占2个字节）
char name = ‘A’; --// String name = “AAA”;

4. Boolean （true 和 false 占1个字节）
   boolean flag = true; boolean flag = false;

（2）引用类型：类 、接口 、数组

二、数据类型转换

->不能对布尔值进行转换

（1）强制类型转换 高->低
int i = 128；
byte d = (byte)i; -->-128 溢出

（2）自动类型转换 低->高

三、变量

（1）类变量:

monthSalary 首字母小写和驼峰原则
由static（定义在 类以内 方法外）— static int maleAge = 10;

（2）实例变量：

从属于对象（定义在 类以内 方法外）-- String str = “hello”;

（3）局部变量：

只能在函数内部可直接使用的变量

四、常量：

设定后不允许被改变的值（大写字母和下划线 MAX_AGE) -->修饰符 final
static final double PI = 3.14; / final static double PI = 3.14; //修饰符不存在先后顺序

五、Scanner 对象 ：

来获取用户的输入
Scanner scanner = new Scanner(System.in);

（1）next() – 不能得到带有空格之后的字符串
scanner.next() -->使用next 方法接收 程序等用户输入完
（2）nextLine() --除了回车符 可以获得任何字符的字符串

九九乘法表：

 		for(int j =1;j<=9;j++){
               for (int i = 1; i <=j; i++){
               System.out.print(i +"*"+ j +"="+ (i*j)+"\t");
               
          }
          System.out.println("\n");
     }

打印三角形 5行：

		for (int i=1;i<=5;i++){
               for (int j = 5;j>=i;j--){
                    System.out.print(" ");                    
               }
               for(int j = 1; j<=i;j++){
                    System.out.print("*");
               }
               for(int j = 1; j<i;j++){
                    System.out.print("*");
               }
               System.out.println("\n");
          }

六、增强for循环

变量名：数组名

 for (int x:nums){
	System.out.printIn(x);
}

七、方法

（1）方法的重载：

一个类里面多个方法
方法名称必须相同、参数类型必须不同 与返回类型无关

（2）静态方法（有 static）和非静态方法（没有 static）：

静态方法调用(和类一起加载)：直接 对象名.方法名
Student.say( )
静态方法没有 this 关键字、静态方法中只能访问静态

非静态方法调用(实例化之后才存在)： 先实例化（ new），再 调用
Student student = new Student( );
student.say( );
非静态方法可以访问所有

*（3）构造方法：

作用：给成员变量进行初始化值。
构造方法必须和类的 类名相同、没有类型（void、int 都不是）
public name （）{ }
继承中： 子类不继承父类的构造方法
super( ) 必须在父类构造方法中的 第一条!
访问无参构造：super( );
访问有参构造：super( a , b );

a 无参数构造方法：

	public Student(){
        System.out.println("111");
    }

b 有参数构造方法：

	public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

new方法时：Student student = new Student(“amy”,20);

注意：如果没有定义构造方法，系统会默认给一个无参构造方法(定义了构造方法，不再提供默认构造方法) 有参和无参一般都写。

八、数组

（1）创建数组: int[ ] nums = new int[10];
（2）数组的初始化： int[ ] a = {1,2,3,4,5,6}; int a[2][1] = {{1,2},{3,4},{5,6}};

九、Arrays类的使用（常用的方法）

打印数组元素：Arrays.toString( );
排序(升序): Arrays.sort( );

十、封装

类里面的属性最好不要public ，使用 private 将类里面的属性私有，需要用私有属性：

私有属性： private String name;
a. 利用public里面的 get 方法获取这个数据（对外提供）

	public String getName(){
		return this.name;
}

b. 利用 set 方法给这个数据设置值 *需要写参数（接收数据）

	public void setName(String name){
		this.name = name;
}

c. 在main函数中new这个类，然后调用 setName() 方法，打印getName()

	Student s1 = new Student();
	s1.setName("RRT");
	System.out.println(s1.getName( ));

this关键字：区分 成员变量和局部变量

	System.out.println(num);   ---局部变量
    System.out.println(this.num);  ---成员变量

十一、继承

（1）关键字 extends

子类会继承了父类，就会拥有父类的全部方法！
父类 ： public class Person{}
子类： public class Student extends Person{}
注意：如果父类有私有属性，子类是不能直接继承的 但是父 类可以封装一些方法从而子类继承
Java中 所有的类都会直接或间接继承 object 类
只有单继承 不能多继承
子类不能直接继承父类的构造方法

（2）关键字 super

子类和父类中拥有相同的构造方法，调用此构造方法只会调用子类内的构造方法，
如果需要调用父类的构造方法 就必须使用关键字 super
注意：super( ) 必须在父类构造方法中的 第一条!
super( ) 只能出现在 子类 的方法或构造方法中!只能在继承条件下才可以使用

this( )–>本类的构造 super( ) --> 父类的构造

	System.out.println(name);   ---从局部位置开始往上找
   	System.out.println(this.name);   ---从本类成员位置开始往上找
    System.out.println(super.name);  ---从父类位置开始往上找

（3）方法重写：

子类出现了和父类一模一样的方法声明，我们就称子类这个方法是重写方法
重新是方法的重写，和属性无关。
注意：需要有继承关系，子类重写了父类的方法，执行子类的方法，不能是 static
方法名必须相同、参数列表必须相同
静态方法和非静态方法有很大的区别
重新原因：父类的功能，子类不一定需要或不一定满足

十二、多态

同类型的对象，表现出的不同形态。

（1）有继承关系、方法需要重新 Object > 父类 > 子类
Student s1 = new Student( ); -->new自己的类 (能调用的方法都是自己或继承父类的)
*** Person s2 = new Student( ); -->父亲的引用指向子类 (可以指向子类，但不能调用子类独有的方法)
（编译看左边，运行看右边）编译时会在父类中找有无这个方法，如果有会执行右边的方法，如果没有报错
Object s3 = new Student( ); -->任何类都带 Object

（2）instanceof 和 类型转换
X instanceof Y -->能不能编译通过就是看 X和Y之间是否有父子关系
类型转换 高 --> 低
Person s1 = new Student( );
( (Student)s1 ).方法( );
低–>高 可直接转换

十三、抽象类

关键字：abstract
注意：不能 new 这个抽象类，只能靠子类去约束它
抽象类里面可以写普通方法和抽象方法，但 抽象方法只能在抽象类中

十四、接口

关键字：interface
作用：定义一些方法，让不同的类实现（比如多个类用不同方式实现同一个方法）
接口中所有的定义其实都是抽象的 public abstract void eat( );（public abstract可省略不写）

用一个类实现一个接口 ：
关键词：implements 一个接口
实现了接口的类 必须重写接口中的抽象方法

在接口内的方法 用 default 定义时 ，它不是抽象方法，可以不用重写
public default void eat( ){ }

十五、内部类

在类里面再写一个类就是内部类、
内部类可以获得外部类的 私有属性和方法

十六、异常

关键字：try(有误走catch)、catch、finally(对不对都会执行)、throw、throws
try和catch不能省，别的可以
（1）父子类转换异常 classCastException！
（2）抛出异常和捕获异常
try {
System.out.println(2/0);
}catch(Error e) {
System.out.println(" ");
}catch(Exception e) {
System.out.println(“Exception”);
}catch(Throwable t) {
System.out.println(“Throwable”);
finally {
System.out.println(“finally”);
}

注意：捕获异常时需要层层递进 Error<Exception <Throwable(大的不能在小的前面)

Java是单继承，只能有一个父类。
一个类可以有多个接口。

Scanner sc = new Scanner(System.in);
String n = sc.nextLine();
char c[] = n.toCharArray();