2021-09-13

1.HelloWorld

package com.lq;

public class Test01 {
    public static void main(String[] args){
        System.out.println("Hello,world");
    }
}

2.Person

package com.lq;

public class Person {
    int age;
    String name;
    double height;
    double weight;

    public void eat(){
        System.out.println("I like eat");
    }

    public void sleep(String address){
        System.out.println("I sleep in the"+address);
    }

    public String introduce(){
        return "My name is "+name+" ,my age is "+age+" ,my height is "+height+" ,my weight is "+weight;
    }
}

package com.lq;

public class TestPerson {
    public static void main(String[] args) {
        Person zs=new Person();
        zs.name="zhang_san";
        zs.age=19;
        zs.height=180.4;
        zs.weight=130;

        Person ls=new Person();
        ls.name="li_si";
        ls.age=19;
        ls.height=180.4;
        ls.weight=130;

        System.out.println("zs.name");
        System.out.println("ls.name");

        zs.eat();
        ls.eat();

        zs.sleep("school");

        System.out.println(zs.introduce());
    }
}

3.Student001

package com.lq001;

public class Student {
    String name;
    int age;
    double height;

    public Student(){

    }
    public Student(String name,int age,double height){
        this.name=name;
        this.age=age;
        this.height=height;
    }
    public Student(String a,int b){
        name=a;
        age=b;
    }
    public void eat(){
        System.out.println("I like eat");
    }
}

package com.lq001;

public class Student_test {
    public static void main(String[] args) {
        Student p=new Student();
        p.age=19;
        p.name="lili";
        p.height=180.4;

        Student p2=new Student("lilli",19,180.4);
        System.out.println(p2.age);
        System.out.println(p2.height);
        System.out.println(p2.name);


    }
}

4.Student002

package com.lq002;

public class Student {
    private int age;
    private String name;
    private String sex;

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        if("man".equals(sex)||"woman".equals(sex)){
            this.sex=sex;
        }
        else{
            this.sex="man";
        }
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(){

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

package com.lq002;


class StudentTest {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setName("nana");
        s1.setAge(19);
        s1.setSex("woman");
        System.out.println(s1.getName()+"---"+s1.getAge()+"---"+s1.getSex());

        Student s2=new Student(18,"didi","agwoeijfa");
        System.out.println(s2.getName()+"---"+s2.getAge()+"---"+s2.getSex());
    }

}

Java网课
0902：
【1】具体dos命令；
（1）切换盘符：c: d: e: 大小写不区分
（2）显示详细信息：dir
（3）改变当前目录：cd
（4）当前目录 .
上一级目录 …
（5）清屏：cls
（6）切换历史命令：上下箭头
（7）补全命令：tab按键
（8）创建目录：md
删除目录：rd
（9）复制文件命令：copy
（10）删除文件：del
del后面如果接的是文件夹/目录：那么删除的就是这个文件夹下的文件，
而不是文件夹。

【2】程序中的常见问题
一个源文件中可以有多个类，只能由一个类被public修饰，源文件的名字必须跟public修饰的那个类名保持一致。
多个类会产生独立的字节码文件。
javac HelloWorld.java
执行的时候执行各自独立的字节码文件即可。
java HelloWorld
java Helloworld2

【3】文档注释
/**
@author liuqin
@version 1.0
这是我们第一章文档注释的代码，比较重要
*/
E：MyJava-code>javadoc -d myHello -author -version Helloworld.java

【4】字符
一个变量被final修饰，这个变量就变成了一个常量，其值不可变。
字符常量的值全部大写。

【5】cin>>
文字扫描器 import java.util.Scanner;
Scanner sc=new Scanner(System.in);
int r=sc.nextInt();
【6】运算符
‘6’表示一个字符，实际上是56.
“6”表示一个字符串，没有数字含义。

a+=b 运算效率搞，底层自动类型转换

&逻辑与 两边都判断
&&短路与 只要左边确定是false,右边就跳过而直接是false

^两边相同为false,不相同为true

<<左移两位相当于乘四，左移三位相当于乘八。

【7】数组。
静态初始化：直接在定义数组的同时就为数组元素分配空间并赋值。
int[] arr={12,23,34};
int[] arr=new int[]{12,34,45};

new int[3]{12,34,56} —>错误。
int arr;
arr={12,34,45} —>错误。

动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。
int[] arr=new int[3];
arr[0]=12;
arr[1]=23;
arr[2]=45;

【8】Eclipse 和IDEA
Eclipse中workspaces相当于IDEA中的Project.
Eclipse中Project相当于IDEA中的Module.

在IntelliJ IDEA中Project是最顶级的级别，次级别是Module(模块）。
一个Project下可以有多个Module.

out目录存放编译后的文件。

删除模块先remove，后delete。

【9】IDEA常用设置
手动导包：new Date(); 快捷键alt+enter.
自动导包和优化多余的包。

【10】常用快捷键
创建内容：alt+insert
main方法：psvm
输出语句：sout
复制一行：ctrl+d
删除一行：ctrl+y
代码向上/下移动：ctrl+shift+up/down
搜索类：ctrl+n
生成代码：alt+insert(如构造函数等，getter,setter,hashcode,equals,tostring)
百能快捷键：alt+enter(导包，生成变量等）
单行注释或多行注释：ctrl+/或ctrl+shift+/
重命名： shift+f6
for循环 直接：for回车即可。
代码块包围：try-catch,if,while等 ctrl+alt+t
代码自动补全提示：
代码一层一层调用的快捷键：
显示代码结构：alt+7
显示导航栏：alt+7
缩进和取消缩进：tab shift+tab

【11】代码模板
Live templates中可以做用户的个性化定制。
Postfix Completion 中只能用，不能修改。

live templates 直接键入。Postfix completion , aaa.fori 作为后缀键入。

【12】常用代码模板
main方法：main或者psvm.
输出语句：sout或者.sout 一些变型：soutp:打印方法的形参 soutm:打印方法的名字 soutv:打印变量
循环：普通for循环：fori(正向) 或者.fori(正向) .forr(逆向）
增强for循环：iter 或者 .for（可以用于数组的遍历，集合的遍历）
条件判断：ifn或者.null: 判断是否为null(if null)
inn或者.nn:判断不等于null(if not null)
属性修饰符：prst:private static final
pst:public static final

【13】常用的断点调试快捷键：
蓝色拐弯箭头：一步一步的向下运行代码，不会走入任何方法中。
蓝色垂直箭头：一步一步的向下运行代码，不会走入系统类库的方法中，但会走入自定义的方法中。
红色垂直箭头：一步一步的向下运行代码，会走入系统类库的方法中，也会走入自定义的方法中。
蓝色向上箭头：跳出方法。
红色方块箭头：结束程序。
绿色右三角箭头：进入到下一个断点，如果没有下一个断点了，就直接运行到程序结束。
禁止断点：结束当前次未执行的断点。

调试的时候，在循环里增加条件判断。 具体操作：在断点处调出条件断点，可以在满足某个条件下，实施断点。
查看表达式的值。选择行，alt+f8

【14】面向过程和面向对象
面向过程：当事件比较简单的时候，利用面向过程，注重的是事件的具体的步骤/过程，注重的是过程中的具体的行为，
以函数为最小单位，考虑怎么做。
面向对象：注重找“参与者”，将功能封装进对象，强调具备了功能的对象，以类/对象未最小单位，考虑谁来做。

面向过程–>面向对象，其实就是由执行者—>指挥者的一个过渡。

二者相辅相成，不是对立的，解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间复杂的关系，方便我们分析整个系统；
具体到微观操作，仍然使用面向过程方式来处理。

【15】对象：具体的事物，具体的实体，具体的实例，模板下具体的产品。
类：对对象向上抽取出像的部分，公共的部分，形成类，类是抽象的，是一个模板。
写代码的时候先创建类，再创建对应的实体。

【16】面向对象三个阶段：
面向对象分析OOA—Object Oriented Analysis
对象：张三，王五，朱六，你，我。
抽取出一个类—》人类

类里面有什么：
动词–》动态特性–》方法
名词–》静态特性–》属性

面向对象设计OOD—Object Oriented Design
先有类，再有对象
类：人类：peison
对象：zhangsna,lisi,zhuliu

面向对象编程OOP–Object Oriented Programing
属性：
属性用于定义该类或该类对象包含的数据或者说静态特征，属性作用范围是整个类体。
属性定义格式：
【修饰符】 属性类型 属性名=【默认值】；

方法：
方法用于定义该类或该类实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向
过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个
程序的基本单位是累，方法是属于类和对象的。

方法定义格式：
【修饰符】方法返回值类型 方法名（形参列表）{
//n条语句
}
void 代表没有返回值；
方法的作用：重用代码，封装功能，便于修改。

局部变量：放在方法中，需要初始值
成员变量：放在方法外

【17】创建类：
创建对象之后再开一个测试类。
new一个对象，开一个内存，用引用类型接收。 Person a=new Person();
第一次加载类的时候，会进行类的加载，初始化创建对象的时候，对象的属性没有给赋值，有默认的初始化的值。
再次创建类的时候，就不会进行类的加载了，类的加载只在第一次需要的时候加载一次。
不同的对象，属性有自己特有的值，但是方法都是调用类中通用的方法。

【18】成员变量和局部变量
区别一：代码中位置不同
成员变量：类中方法外定义的变量
局部变量：方法中定义的变量，代码块中定义的变量

区别二：代码的作用范围
成员变量：当前类的很多方法
局部变量：当前的一个方法（当前代码块）

区别三：是否有默认值
成员变量：有
局部变量：没有。

区别四：是否要初始化
成员变量：不需要
局部变量：一定需要

区别五：内存中位置不同
成员变量：堆内存
局部变量：栈内存

区别六：作用时间不同
成员变量：当前对象从创建到销毁
局部变量：当前方法从开始执行到执行完毕。

【19】基本类型的默认值
booleam false
char "\u0000’(null)
byte (tyte)0
short (short)0
int 0
long 0L
float 0.0f
double 0.0d
string null

【20】构造器
创建对象的过程：
1.第一次遇到Person的时候，进行类的加载（只加载一次）
2.创建对象，为这个对象再堆中开辟空间
3.对对象进行属性的初始化动作。

new关键字实际上是在调用一个方法，这个方法叫构造方法（构造器）
调用构造器的时候，如果你的类中没有写构造器，那么系统会默认给你分配一个构造器，只是我们看不到罢了。
可以自己显示的将构造器编写出来；
构造器的格式：
【修饰符】 构造器名字（）{

}

构造器和方法的区别：
1.没有方法的返回值类型。
2.方法体内部不能有return语句。
3，构造器的名字很特殊，必须跟类名一样。

注意：我们一般不会在空构造器中进行初始化，因为那样的话每个对象的属性就一样了。
实际上，我们只要保证空构造器的存在就可以了，里面的东西不用写。

【21】构造器的重载
1.一般保证空构造器的存在，空构造器中一般不会进行属性的赋值操作
2，一般我们会重载构造器，在重载的构造器中进行属性的赋值操作
3，在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错。
4.当形参名字和属性名字重名的时候，会出现就近原则：
在要表示的回想的属性前加上this.来修饰，因为this代表的就是你创建的那个对象。

【22】this
创建对象的过程：
在第一次遇到一个类的时候，对这个类进行加载，只加载一次。
创建对象，在堆中开辟空间。
对对象进行初始化操作，属性赋值都是默认的初始值。
new关键字调用构造器，执行构造方法，在构造器中对属性重新进行赋值。

this指的是正在创建，当前调用的对象。

this关键字 用法：
1.this 可以修饰属性：当属性名字和形参发生重名的时候，或者属性名字和局部变量重名的时候，都会发生
就近原则，所以如果我要是直接使用变量名字的话，就指的是离的近的那个形参或局部变量，这时候如果我想要表示
属性的话，在前面加上：this.修饰。
如果不发生重名问题的话，实际上你要是访问属性也可以省略this。

2.this可以修饰方法：在同一个类中，方法可以互相调用，this.可以省略不写。
public void play(){
eat();
System.out.println("上网“}；
System.out.println("洗澡”）
public void eat(){
System.out.println("吃饭“}；

3.this 也可以修饰构造器：同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行。

public Person (int age,String name,double height){
this(age,name)
this.height=height;
}
public Person(int age,String name){
this(age);
this.name=name;
public Person(int age){
this.age=age;
}

【23】static
1,static 可以修饰：属性，方法，代码块，内部类。布恩那个修饰构造器。

栈里存放局部变量，形参。
堆里存放对象，数组。
方法区里存放字节码信息，字符串常量池。

2.static修饰属性：
在类加载的时候，会将静态内容也加载到方法区的静态域中。
静态的内容先于对象存在。静态内容别所有该类的对象共享。
一般官方的推荐访问方式：可以通过类名.属性名的方式去访问。Test.sid=100;

3.static修饰属性的应用场景：某些特定的数据想要在内存中共享，只有一块—》这种情况下，就可以用static修饰的属性。
属性： 静态属性（类变量） 非静态属性（实例变量）

4.static修饰方法。
static 和public 都是修饰符，并列的没有先后顺序，先写谁后下谁都行。
在静态方法中不饿能访问非静态属性，方法，不能使用this关键字。因为static的内容咸鱼对象存在。
非静态方法可以用对象名.方法名调用，静态方法除此之外还可以用类名.方法名调用（推荐）

0913

【24】代码块的分类：普通块，构造块，静态块，同步块（多线程）
普通块：在方法中，限制了局部变量的作用范围。
构造块：在方法外写的代码需要加构造块。
静态块：static 修饰的构造块就是静态块。静态块中只能访问静态变量和静态方法。

总结：
1，代码块的执行顺序：
静态块最先执行，只在类加载的时候执行一次，（在类被加载的时候直接执行），所以一般以后实战写项目：
创建工厂，数据库的初始化信息都放入静态块。一般用于执行一些全局性的初始化操作。

在执行构造块，（不常用）
在执行构造器。（初始化操作）
再执行方法块中的普通块。

【25】包
1.包的作用：
为了解决重名问题（实际上包对应的就是盘符上的目录）
解决权限问题（不同包之间的访问权限）

2.创建包
包名定义:名字全部小写
中间用.隔开
一般都是公司域名到着写：com.jd com.msb
加上模块的名字 com.jd.login com.jd.register
不能使用系统中的关键字：nul ,con,com1----com9…
包声明的位置一般都在非注释性代码的第一行

3.导包
使用不同包下的类需要导包：import *..;例如：import java.util.Date;导包就是为了定位。
在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。
同一个包下的类想使用不需要导包，可以直接使用
在java.lang 包下的类，可以直接使用无需导包：System.out.println(Math.random();
IDEA中导包快捷键：alt+enter;可以自己设置自动导包。
可以直接导入： /import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;/
import java.util.*; //*代表所有。

4.在Java中的导包没有包含和被包含的关系：
设置目录平级的格式（不是包含和被包含的显示）
import com.msb9.*;
import com.msb9.sub.D;

5.静态导入
import static java.lang.Math.*; //导入java.lang下的Math类中的所有静态的的内容。
System.out.println(random()）；//前面的Math.没写。
System.out.println(PI）；
System.out.println(round(5.6)）；
在静态导入后，同一个类中有相同方法的时候，会优先走自己定义的方法。

【26】封装
1，java中封装的理解：
将某些东西进行隐藏，然后提供相应的方式进行获取。
封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、
封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。什么是封装？
封装把对象的多有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。
适当的封装可以让程式码更容易理解和维护，也加强了程序吗的安全性。

我们程序设计追求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口，便于外界调用，从而提高程序的可扩展性、可维护性。
通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.封装的好处。

3.上面的代码，对于属性age来说，加了修饰符private,这样外界对他的访问就受到了限制，现在还想加上其他的限制条件，
但是在属性本身身上没有办法再加了，所以我们通过定义方法来进行限制条件的添加。
例：
public class Girl{
private int age;
private int duquAge(){
return age;
}
public void shezhiAge(int age){
if(age>-30){
this.age=10;
}
else{
this.age=age;
}
}
}
将属性私有化，被private修饰–》加入权限修饰符，一旦加入了权限修饰符，其他人就不可以随意的获取这个属性
提供public修饰的方法让别人来访问/使用。
即使外界可以通过方法来访问属性了，但是也不能随意访问，因为咱们再方法中可以加入限制条件。

4.实际开发中，方法一般会写成setter ,getter 方法：
可以利用IDEA中的快捷键生成：alt+insert—>getter and setter