JAVA 学习笔记

JAVA|学习笔记

数据类型

1. 基本数据类型：

四类：整型，浮点型，字符型，布尔

八种：

类型	关键字	包裹类型	大小 (字节)
字节型	byte	Byte	1
短整型	short	Short	2
整型	int	Integer	4
长整型	long	Long	8
单精度浮点	float	Float	4
双精度浮点	double	Double	8
字符型	char	Character	2
布尔型	boolean	Boolean	1

2. 引用数据类型

类，数组，接口

权限修饰符

$\checkmark$ 表示是否可以访问类内被下述修饰符修饰($pubic — protected — default — private$)变量的值

	public	protected	default	private
同一个类内	$\checkmark$	$\checkmark$	$\checkmark$	$\checkmark$
同一个包内（子类或无关子类）	$\checkmark$	$\checkmark$	$\checkmark$
不同包的子类	$\checkmark$	$\checkmark$
不同包的无关类	$\checkmark$

类的权限修饰符

$\checkmark$ 表示是否可以使用

	$public$	$protected$	$default$	$default$
外部类（普通）	$\checkmark$		$\checkmark$
成员内部类	$\checkmark$	$\checkmark$	$\checkmark$	$\checkmark$
局部内部类（无，都不能用）

内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类

1. 成员内部类

定义在B类成员方法外部的类

调用方式

直接调用方式

1 2	外部类名.内部类名对象名 = new 外部类型().new 内部类型(); Outter.Inner inner=new Outter().new Inner();

间接调用方式

public class Outter
{
    private String name = "Outter";

    //成员内部类
    public class Inner
    {
        private String name = "Inner";

        public void show_name()
        {
            //重名解决办法
            System.out.println(this.name);
            System.out.println(Outter.this.name);
        }
    }

    //外 访问 内 间接访问方法
    public void useinner()
    {
        Inner inner = new Inner();
        inner.show_name();
    }

    //局部内部类
    public void local_InnerClass_method()
    {
        class Inner
        {
            public void local_InnerClass_show()
            {
                System.out.println("局部内部类方法");
            }
        }
        Inner inner = new Inner();
        inner.local_InnerClass_show();
    }
}

public class use
{
    public static void main(String[] args)
    {
        Outter outter = new Outter();
        //1.成员内部类的间接调用
        outter.useinner();
        //2.成员内部类的直接调用
        Outter.Inner inner = new Outter().new Inner();
        inner.show_name();
        //3.局部内部类的方法的调用
        outter.local_InnerClass_method();
    }
}

2. 局部内部类

定义在B类成员方法内部的类
调用方式
- 调用方式（见上述代码）
注意事项

局部内部类若是想要使用所在成员方法中的局部变量，这个局部变量必须要被 $final$ 修饰，并且有初始值

原因：
1. 成员方法与局部变量是存放在栈内存当中，局部变量随着方法的弹出而消失
2. 但局部内部类是存放在堆内存当中的，是一直存在的直到垃圾回收
3. 所以说局部内部类的生存周期要比局部变量长，但你还继续使用，这个内部类就会拷贝一份局部变量的初始值，这样
访问特点
1. 内 - 访问 - 外，直接访问（参考上面的代码）
2. 外 - 访问 - 内，需要实例化一个内部类的对象（参考上面的代码）

3. 匿名内部类（也是局部内部类）

注意匿名内部类匿名的是类名不是对象名

而匿名对象匿名的是对象名,例如： new Student().study();
1

//定义一个接口
public interface Myinterface
{
    public abstract void run();
    public abstract void run2();
}
//定义一个实现类
public class Myinterfaceimp implements Myinterface
{
    @Override
    public void run()
    {
        System.out.println("实现类，重写接口的抽象方法1");
    }

    @Override
    public void run2()
    {
        System.out.println("实现类，重写接口的抽象方法2");
    }
}
//定义一个主函数
public class Main
{
    public static void main(String[] args)
    {
        //通过实现类 来重写接口中所有的抽象方法
        Myinterfaceimp myinterfaceimp = new Myinterfaceimp();
        myinterfaceimp.run();
        myinterfaceimp.run2();

        //通过匿名内部类 来实现接口中抽象方法
        //匿名内部类 匿名的是 类的名称 并没有匿名对象名称 下边这个 对象名是myinterface
        Myinterface myinterface = new Myinterface()
        {
            @Override
            public void run()
            {
                System.out.println("匿名内部类 重写接口的抽象方法1");
            }

            @Override
            public void run2()
            {
                System.out.println("匿名内部类 重写接口的抽象方法2");
            }
        };
        myinterface.run();
        myinterface.run2();

        //匿名对象内部类 对象名也省了，只能执行接口中所有抽象方法中的一个
        new Myinterface(){

            @Override
            public void run()
            {
                System.out.println("匿名对象内部类 重写接口的抽象方法1");
            }

            @Override
            public void run2()
            {
                System.out.println("匿名对象内部类 重写接口的抽象方法1");
            }
        }.run();//只能执行一个抽象方法

    }
}

封装

1. private

private是一个权限修饰符，代表最小权限。
可以修饰成员变量和成员方法。
被private修饰后的成员变量和成员方法，只在本类中才能访问。
对需要访问的成员变量，提供对应的一对 getXxx 方法、setXxx 方法。
this 的使用 this.成员变量名。

2. public

3. 构造方法

如果你不提供构造方法，系统会给出无参数构造方法。
如果你提供了构造方法，系统将不再提供无参数构造方法。
构造方法是可以重载的，既可以定义参数，也可以不定义参数。

public class Student 
{
	private String name;
	private int age;
    // 无参数构造方法
    public Student() {}
    // 有参数构造方法
    public Student(String name,int age)
    {
    this.name = name;
    this.age = age;
	}
}

4. 标准代码——JavaBean

getter
setter

5. 自定义类作为成员变量

6. 自定义接口作为成员变量

7. 自定义接口作为成员方法的参数、返回类型

继承

定义：
继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。
优点：
代码复用，多态的前提

格式

class 父类 
{
...
}
class 子类 extends 父类 
{
...
}

特点
1. 成员变量
  - 重名：通过 $ this.super$ 来区分
  - 不重名：可以直接访问父类的非私有变量
2. 成员函数
  - 重名：子类重写了父类的函数，执行子类的方法
  - 不重名：先看子类有没有这个方法，再去父类查找
3. 构造函数
  - 构造方法的名字与类名一致，所以子类是无法继承父类构造方法的。
  - 子类在初始化时，会先执行父类的构造方法，这是因为在子类的构造方法中有一个$super()$ 会执行父类的构造方法

多态

定义
多态：是指同一行为，具有多个不同表现形式。

优点

多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

例如：

public class Test {
    public static void main(String[] args) {
    // 多态形式，创建对象
    Cat c = new Cat();
    Dog d = new Dog();
    // 调用showCatEat
    showCatEat(c);
    // 调用showDogEat
        showDogEat(d);
    /*
    以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代
    而执行效果一致
    */
    showAnimalEat(c);
    showAnimalEat(d);
    }
    public static void showCatEat (Cat c){
    	c.eat();
    }
    public static void showDogEat (Dog d){
    	d.eat();
    }
    public static void showAnimalEat (Animal a){
    	a.eat();
    }

上述代码注意最后三个函数的形参如果没有多态，需要写两个函数一个形参是Cat类型,一个形参是 Dog类型，这俩都是Animal的子类，而最后一个就直接用Animal就省了好多代码

格式

1 2	父类类型变量名 = new 子类对象；变量名.方法名();

特点
1. 当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；有的话，执行子类的重写方法
引用类型转换
为什么要转型？多态带来的麻烦

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。
1. 向上类型转换（默认）
2. 向下类型转换（可能会出错）

API

数组
1
2
int[] arr = new int[10];
arr.length

ArrayList<>

1 2	ArrayList<String> arr = new ArrayList<>(); arr.size()

String

1 2	String s="123"; System.out.println(s.length());