基础知识识

创建对象

public class java {
    public static void main(String[] args) {
    /* 通常情况下，一个类不额能直接使用，需要根据类创建一个对象，才能使用
    1.导包：指出需要使用的类，在什么位置
    import 包名称.类名称;
    import student   对于和当前类同一个包的情况，可以省略导包语句
    * */
        student stu = new student();
        System.out.println( stu.name);//null
        System.out.println( stu.age);//0
        System.out.println( "======================================");
        stu.name = "赵丽颖";
        stu.age  = 18;

        System.out.println( stu.name);//赵丽颖
        System.out.println( stu.age);//18
    }
}

public class student {
    /*
    注意事项：成员变量是直接定义在类当中的  成员方法不写static关键字
     */
    String name;
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void study(){
        System.out.println("学习");
    }

}

四十八.多态

格式：

父类名称 对象名 = new 子类名称（）； //一条命令 建立两个对象

或者：

接口名称 对象名 = new 实现类名称（）；

fu obj = new ZI();
obj.method(); 优先用子
obj.methodFu();优先用子 子类无 用父类

访问成员成员变量的两种方式：
1.直接通过对象名称访问成员变量，优先用创建对象时的左边 没有则向上找（左边最高继承关系时object）
2.间接访问成员对象方法访问成员变量，方法属于谁优先用谁（多态中调用方法时 子类优先）
Fu obj  = new Zi();
syso/(obj.num);//调用变量时 优先用父 父类无则向上找
obj.shouNum();//父子重名方法 调用方法时优先用子 子类无则向上找
obj.methodZi();//多态里 子类只能改写 不能自创方法 否则会报错 

向下转型
格式：子类名称 对象名 = （子类名称） 父类对象；			
Animal annimal = new Cat ();
//animal.catchMouse();因为父类没有catchMouse() 子类有  子类此时不能自创方法
//解决办法：
Cat cat = (Cat)animal;
animal.catchMouse();

private关键字的作用和使用（可以限制年龄在合适的区间 以防出错）
问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来-20
解决方案：用private关键字将需要保护的成员变量进行修饰
一旦使用private进行修饰，本类当中仍然可以随意访问
但是超出本类范围就不能再直接访问

间接访问private成员变量，就是定义一堆Getter/Setter
对于 Getter来说，不能有参数，返回值类型和成员变量对应
对于Setter来说，不能有返回值，参数类型和成员变量对应
public clss Person{
    String name ;
    private int age;
    public void show(){
        syso("我叫："+name+",年龄："+age);
    }
    //这个成员方法，专门用于向age设置数据
    public void setAge(int num){
        if(num < 100 && num >= 9){
        age = num;
    }
    else{
        syso("数据不合理");
    }
    }
    //这个成员方法，专门私语获取age的数据
    public void getAge(){
        return age;
    }
}

main{
    Person person = new Person();
    person.show();
    //我叫null,年龄：0
    person.name="赵丽颖";
    //person.age = -20;错误，不能直接放访问private内容
    person.setAge(20);
    person.show();
    //我叫赵丽颖，年龄：20
}

ArrayList集合

import java.util.ArrayList;

public class ArrayList22 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("迪丽热妈");
        list.add("玛尔扎哈");
        list.add("贾克斯");
        list.add("塔姆");
        System.out.println(list);//[迪丽热妈, 玛尔扎哈, 贾克斯]

        //ArrayList常用方法
        //从集合中获取元素,get 索引值从0开始
        String name = list.get(2);
        System.out.println("第2号索引位置:"+name);

        //从集合删除元素 remove 索引值从0开始
        String whoRemoved = list.remove(3);//index:索引
        System.out.println("被删除的是"+whoRemoved);//被删除的是塔姆
        System.out.println(list);//[迪丽热妈, 玛尔扎哈, 贾克斯]

        //获取集合 的长度，也就是其中元素的个数
        int size = list.size();
        System.out.println("集合的长度："+size);//集合的长度：3
    }
}

代码照着抄  照板  编译器出错容易燥s

import java.util.ArrayList;

public class ArrayListBasic {
    public static void main(String[] args) {
        /**
        如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的"包装类"
        基本类型    包装类（引用类型，包装类都位于java.lang包下）
        byte        Byte
        short       Short
        int         Integer [特殊]
        float       Float
        double      Double
        char        Character [特殊]
        boolean     Boolean
        从JDK 1.5+开始 支持自动装箱 自动拆箱
        自动装箱：基本类型 --> 包装类型
        自动拆箱：包装类型 --> 基本类型
         */
        ArrayList<String> listA = new ArrayList<>();
        //错误写法 泛型只能是引用类型 不能是基本类型
        //ArrayList<int> listB = new ArrayList();

        ArrayList<Integer> listC = new ArrayList<>();
        listC.add(100);
        listC.add(200);
        System.out.println(listC);//[100, 200]

        int num = listC.get(1);
        System.out.println("第1号元素是："+num);//第1号元素是：200

    }
}

 泛型 

import java.util.ArrayList;
import java.util.ArrayList;
import java.util.Iterator;

public class Generic {
    public static void main(String[] args) {
        show1();
    }
    /*创建集合对象不适用泛型
    好处：
        集合不使用泛型，默认的类型就是Object类型，可以存储任何类型的数据
    弊端：
        不安全，会引发异常
       E- Element （在集合中使用元素）
       T- Type（JAVA类）
       K- Kye（键）
       V- Value（值）
       N-Number（数值类型）
     */
    private static void show1(){
        ArrayList list = new ArrayList<>();
        list.add("迪丽热妈");
        list.add(1);

        Iterator  it =list.iterator();
        while(it.hasNext()){
        Object obj = it.next();
        System.out.println(obj);}
        /*想要使用String特有的方法，length获取字符串长度；不能使用 
        多态 Object obj = "abc"  需要向下转型*/ 
        //String s = (String)obj;
        //System.out.println(s.length());
        

    }
}

四.内部类

/*
* 内部类：一个类内部包含另一个类
* 分类：
* 1.成员内部类
* 2.局部内部类（包括匿名内部类）
* 对象肯定在包里创建class类 才能在main方法调用成功 或者这个类在Object
*如何调用内部类方法
*   1.间接方式：
* 1.先创建内部类（在一个类里创建一个类 在内部类创建方法）
* 2.在外部类方法创建内部类对象并且调用内部类的方法（new Heart().heat();）
* 3.在main方法创建外部类对象 然后调用对象的外部类方法即可（外部类方法里包含调用内部类的方法 了）
*
* 2.直接方式:公式：
*   类名称 对象名 = new 类名称（）
*   外部类名称.内部类名称 对象名 = new 外部类名称（）.new 内部类
*     Body.Heart heart = new Body().new heart();
* */
public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body();
        //通过外部类对象，调用外部类的方法，里面简介在使用内部类Heart
        body.methodBody();

        System.out.println("--------------------------------");
        //按照公式写
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

/*面向对象的思想：
    做一件事情，找一个能解决这个事情对象，调用对象的方法，完成事情。
  函数式编程思想：
    只要能获取到结果，谁去做的，怎么做的都不重要，重视的是结果，不重视过程
* 用IDEA  的快捷键会报错*/
public class Demo01Runnable {
    public static void main(String[] args) {

        RunnableImpl run = new RunnableImpl();
        Thread t = new Thread(run);

        t.start();

        //简化代码，使用匿名内部类，实现多线程程序
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "新线程被创建");
            }
        };
        new Thread (r) .start();;
    }
}

内部类同名变量访问

/*内部类同名变量访问
如果出现了重名现象，那个格式是： 外部类名称.this.外部类成员变量名
1.在内部类的方法调用同名变量 则就近原则获得内部类的成员变量值 （方法里有同名优先用方法内的变量）
2.在内部类方法 this.num  获得内部类的成员变量（不包含方法）
3.在内部类方法获得外部类成员变量 Out.this.num 外部类名称.this.重名变量
 */
public class Outer {
    int num = 10;//外部类成员变量

    public class Inner{
        int num = 20;//内部类成员变量
        public void methodInner(){
            int num = 30;
            System.out.println(num);//局部变量，就近原则
            System.out.println(this.num);//外部类的成员变量
           // System.out.println(super.num); 报错 因为Inner不是继承于Outer 因此语法错误
            System.out.println(Outer.this.num);//外部类的成员变量
        }
    }
}

public class Demo02InnerClass {
    public static void main(String[] args) {


        //外部类名称.内部类名称 对象名 = new 外部类名称（）.new 内部类名称();
        Outer.Inner obj = new Outer().new Inner();
        obj.methodInner();//30 20 10
    }
}

局部内部类final问题

package Demo02;
/*
局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final】
 备注：从JAVA 8+开始，只要局部变量事实不变，那么final关键字可以省略

 原因：
 1.new出的对象在堆内存中
 2.局部变量是跟着方法走的，在栈内存中
 3.方法运行结束之后，立刻出栈，局部变量就会立刻消失
 4.但是new出来的对象会在堆当中持续存在，直到垃圾回收消失
 */
public class MyOuter {
    public void methoodOuter(){
        int num = 10;//所在方法的局部变量
        //num = 20; 如果修改数值 内部类方法无法获得num值*******
        class MyInner{
            public void methodInner(){
                System.out.println(num);
            }
        }
    }
}