Java学习第二阶段总结

如题

这个字体不能换吗，好丑啊。
下面这段代码包括，类，属性，方法，对象的概念，访问修饰符，static使用的总合。

public class Telphone {
    //类名
    static int num = 10;
    float screen;//属性 （有什么）
    private float  cpu;//封装（不能直接访问属性，要通过方法）访问修饰符。
    float mem;
    //初始化块
    {
      int name1 =5;
      System.out.println("初始化块name1:"+name1);
    }
    //静态初始化块(>普通初始化块>方法)，且在类中只加载一次。
    static    {
        int name2 =15;
        System.out.println("静态初始化块name2："+name2);
    }

     //方法（干什么）
    public float getCpu(){  //通过返回值访问封装后的属性
        return cpu;
    }
    public void setCpu(float newCpu){
        System.out.println("SETCPU:"+"赋值，没运行出来属性很正常");
        cpu = newCpu;
    }
    void call(){
        System.out.println("调用方法之成员变量,以及在此之前封装属性cpu通过方法传递了值："+cpu);
    }
    void sengdMessage(){
        screen=8.8f;
        System.out.println("send message"+"构造方法screen:"+screen );
    }
    void  number( float num1){
        mem = num1;
        System.out.println("静态变量num"+Telphone.num);
        System.out.println("有参方法属性传递验证"+num1);
    }
    public static void main(String[] args){
        Telphone phone = new Telphone(); //phone 对象名，创建对象
        phone.sengdMessage();//对象。方法（还有对象.属性）使用对象
        //phone.cpu = 5.0f;(封装后错误的访问，会报错：cpu在Telphone中private访问控制)
        phone.setCpu(1.8f);//封装后正确访问属性，赋值属性
        System.out.println("getcpu:"+phone.getCpu());//得到属性
        phone.call();
        phone.number(2.1f);
        Telphone phone2 = new Telphone();//验证静态初始化块在类中只加载一次。

    }

}

图片里是运行结果。
（要回顾的时候这个代码块看得懂理解的了证明还有得救。）

正文

————————————————————————————
——————————————————————
一、 有关，包，类，属性，方法，对象。（个人记不住概念的理解，看代码块看代码块）
· 包：为了更好地组织类,Java提供了包机制。包是类的容器,用于分隔类名空间。（百度），就是个文件夹一样作用的东西，方便区分同名类嘛
· 类：Java程序都以类class位组织单位。装属性和方法的模子。
· 属性和方法：属性是类有什么，方法是类可以干什么。
（ps，类=手机，属性=cpu，内存···，方法=打电话，上网···）
· 对象：嗯，就是对象，对象就是具有某些的特殊属性(成员变量)和行为方式(方法)的实体（百度），就是手机1，手机2···。
调用方法看上面main方法里的代码，创建一个对象然后让他等于，new一个类。对象是可以引用类里的对象和方法的。
——————————————————————
————————————————————————————
二、面向对象三大特性：封装，继承，多态。（有关访问修饰符，static，this，final，super，保留字）

《封装》
（应用访问修饰符，static，this）：隐藏类的一些信息，不让外部程序直接访问，通过方法来实现对隐藏信息的操作和访问。（代码里属性cpu是被封装的，看代码看代码）
【优点：a。只能通过规定的方法访问数据，b。隐藏类的实例细节，方便修改和实现（2020.1.7.b没感觉出来，觉得更麻烦）】，通过访问修饰符private封装好属性，创建getter，setter方法来访问(代码：setCpu，getCpu)
1. 访问修饰符：
private 　　在当前类中可访问
default 在当前包内和访问
protected 在当前类和它派生的类中可访问
public 公众的访问权限，谁都能访问
我真的受不了没法空格这个操作了，逼死强迫症啊。
2. static，静态变量，静态方法，静态初始化块。（虽然写在封装里和封装没啥关联，就是，写茬了。）
· 静态变量：添加了static修饰，变成类成员，整个类的所有对象都可以使用。
· 静态方法：同样是static关键字声明，可以直接哟个类名调用静态方法。【划重点：静态方法里可以调用同类的静态成员，但是不能用非静态成员，如果非要在里面调用，就得创建类的对象，然后用对象访问。调用方法同理**】** main方法就是个静态方法。
· 静态初始化块：看上面代码，【 静态初始化块只在类加载时执行，且只会执行一次同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。代码里有通过phone1，phone2验证】，而且程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。
3. this：代表当前对象，this.属性：操作当前对象。封装对象属性的时候，常用this关键字。（比如在setcpu里传递的参数取名cpu，在方法里this cpu = cpu，就表示把参数传给当前对象的属性。吧。方法同理，this.方法名）

《继承》
子类拥有父类所有属性和方法。（private修饰过的不能继承），以及只能单继承，就是只有一个亲爹。
语法：class 子类 extend 父类
··· class erza extend baba {
}
1. 方法的重写：子类不满及父类的方法，可以重写父类继承的方法，调用方法的时候会优先调用子类的方法。
语法规则：abc三个都要与父类继承的方法相同，才叫重写。
a参数类型及个数
b返回值类型
c方法名
2. final：可以修饰类，方法，属性，变量。
（修饰类，则该类不允许被继承）
（修饰方法，则该方法不允许被覆盖，重写）
（修饰属性，则该属性不会进行隐式的初始化或在构造方法中赋值。即常量。）【这个属性只能赋一次，不能修改。而且系统不会自动帮你自动初始化，会报错。】
（修饰变量，则该变量的值只能赋一次。）
成为最终的。
3. super：在对象的内部使用，可以代表父类的对象。
1.super.age，访问父类的属性。
2.super.eat()，访问父类的方法。例如，方法以及被重写了，用这个关键字还是可以调用父类的。
【a.如果我们想显式地调用构造方法，必须要写在子类构造方法的第一行。
b.如果子类构造方法既没有显式调用父类的构造方法，而父类又没有无参的构造方法，会报错。（没有显式调用父类构造方法，系统默认调用父类无参的构造方法）
c.子类的构造过程当做必须调用其父类的构造方法。（如果不写super会隐式显示）
】
（构造方法（或者叫构造器）是定义在Java类中的一个用来初始化对象的方法，之前创建新的对象，其实就是用new + 构造方法，名称与类名相同且没有返回值，如果没有写，系统会自动生成一个无参的构造方法，和普通的方法是有区别的。）
这个地方超级绕啊啊啊啊，多写写！！
3. object：暂时没看。
三、 输入输出
1. 输出：System.out.println(···)，System.out.print(···)，前者会多一个换行。
2.输入：要加两个包 " import java.util.* "， " import java.io. "。
输入单个字符：

import java.io.*;
import java.util.*;
public class input{
    public static void main(String[] args)throws IOException{
        char c=(char)System.in.read();//输入
        System.out.println(c);//输出
    }
}

输入字符传，或者整数：

import java.io.*;
import java.util.*;
public class input{
    public static void main(String[] args)throws IOException{
        Scanner cin=new Scanner(System.in);
         
        int a=cin.nextInt();//输入一个整数
        System.out.println(a);
         
        double b=cin.nextDouble();//输入一个双精度的浮点数
        System.out.println(b);
         
        String str=cin.next();//输入一个单词，遇到分号则输入终止
        System.out.println(str);
         
        String str2=cin.nextLine();//输入一行，中间可有多个空格
        System.out.println(str2);
    }
}

csdn里找到的代码，只能记呗。=-=
【上面是用 import 关键字，导入包，import提供路径让编译器找到某个类或者包。】
四、真正的总结（不是）
1.感觉看到这部分才了解第一阶段的语法为什么要那样做，比如调用方法的那段语法，学了构造方法，创建对象才真的掌握。
2.Java核心卷一好多字啊，眼睛都看花了，买了实体书再看吧。
3.我要治好我的拖延症，封装，继承和多态那部分还有点东西没学完，虽然不在计划里提到，但是感觉就是要一起学的东西欸。