Java面向对象2

一、this关键字
1.this的作用:
·this表示的是当前对象本身，
·更准确地说，this代表当前对象的一个引用。
2.普通方法中使用this
·区分类成员属性和方法的形参
·调用当前对象的其他方法（可以省略）
·位置：任意
3.构造方法中使用this
·使用this来调用其它构造方法
·位置：必须是第一条语句
4.this不能用于static方法。（讲完static，大家就知道为什么了！）
5.this测试代码

ublic class TestThis {
	int a,b,c;
	TestThis(){
		System.out.println("正要new一个Hello对象");
	}
	TestThis(int a,int b){
		//Hello();// //这样是无法调用构造方法的！
		this(); //调用无参的构造方法，并且必须位于第一行！
		a = a;//这里都是指的局部变量而不是成员变量
		this.a = a;//这样就区分了成员变量和局部变量. 这种情况占了this使用情况的大多数！
		this.b = b;
	}
	TestThis(int a,int b,int c){
		this(a,b);//调用无参的构造方法，并且必须位于第一行！
		this.c = c;
	}
	void sing(){
	}
	void chifan(){
		this.sing();//sing();
		System.out.println("你妈妈喊你回家吃饭！");
	}
	public static void main(String[] args){
		TestThis hi = new TestThis(2,3);
		hi.chifan();
	}
}

6. 课堂demo【重点掌握】

package netclass02;

/**
 * @Auther: Yu Panpan
 * @Date: 2022/1/7 - 01 - 07 - 14:24
 * @Description: netclass02
 * @version: 1.0
 */

/*
 * this:表示当前对象的指针
 *        指向当前对象，表示当前对象的引用
 * 用途：
 *       1、构造方法，当构造方法中的参数名称跟类的成员变量名称一样的时候，可以使用this代表当前对象
 *                 注意：有了this之后，就可以将构造方法的参数跟成员变量保持一致（符合命名规范）
 *                 当构造方法中需要调用其他的构造方法时，可以使用this(参数列表)调用其他构造方法，但是必须位于方法体的第一行（规则）
 *       2、普通方法中：
 *                 当多个普通方法之间需要相互调用的时候，可以使用this来进行调用，指的是当前对象的其他方法
 *       3、调用成员变量的时候如何使用：
 *                 当方法中的参数名称跟成员变量保持一致的时候，使用 this.变量名称 表示的是对象的值，而使用变量名称表示形参列表中的值
 */
public class ThisDemo {

    //成员变量
    String name;
    int age;

    //构造器、构造方法
    public ThisDemo(){

    }

    public ThisDemo(String name){
        this.name = name;
    }

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

    public void test1(){
        System.out.println("test1被执行");
//        test2();  //也可以省略this来调用其他方法
    }

    public void test2(String name){
        System.out.println("test2被执行");
        this.test1();
        System.out.println(name);
        System.out.println(this.name);
    }

    public static void main(String[] args) {
        ThisDemo td = new ThisDemo("张飞",20);
//        System.out.println(td.name);
//        System.out.println(td.age);
//        td.test1();
        td.test2("赵云");
    }
}

二、static关键字

1.在类中，用static声明的成员变量为静态成员变量 ,或者叫做： 类属性，类变量.

·它为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化
·对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享
·可以使用”对象.类属性”来调用。不过，一般都是用“类名.类属性”
·static变量置于方法区中

2.用static声明的方法为静态方法

·不需要对象，就可以调用(类名.方法名)
·在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员
·静态方法不能以任何方式引用this和super关键字

3.static示例代码

public class TestStatic {
	int a;
	static int width;
	static void gg(){
		System.out.println("gg");
	}
	void tt(){
		System.out.println("tt");
	}
	public static void main(String[] args){
		TestStatic hi = new TestStatic();
		TestStatic.width = 2;
		TestStatic.gg(); //gg();
		//通过引用也可以访问static变量或static方法。不过，一般还是使用类名.static成员名来访问。
		hi.gg();
		gg();
	}
}

1. static关键字

• 使用static声明的成员变量称为静态变量，
• 使用static声明的方法称为静态方法
• 静态变量和静态方法又称为类变量和类方法
• static关键字用法-课堂demo【重点掌握】

package netclass02;

/**
 * @Auther: Yu Panpan
 * @Date: 2022/1/7 - 01 - 07 - 15:17
 * @Description: netclass02
 * @version: 1.0
 */
/*
 *  使用static统计在类中一共产生多少个对象?
 */
public class StaticDemo2 {

    static int count;
//    int count;

    public StaticDemo2(){
        count++;
        System.out.println("创建了" +count + "个对象");
    }

    public static void main(String[] args) {
        new StaticDemo2();//1
        new StaticDemo2();//2
        new StaticDemo2();//3
    }
}

 三、代码块
1.概念:使用”{}”括起来的一段代码
2.分类：根据位置可分类
·普通代码块—>直接在方法或语句中定义的代码块
·构造代码块—>直接写在类中的代码块
·静态代码块—>使用static声明的代码块
·同步代码块—>多线程的时候会学到
3.静态初始化块
·如果希望加载后，对整个类进行某些初始化操作，可以使用static初始化块。
·类第一次被载入时先执行static代码块；类多次载入时，static代码块只执行一次；static经常用来
·进行static变量的初始化。
·是在类初始化时执行，不是在创建对象时执行。
·静态初始化块中不能访问非static成员。
·demo
 

public class TestStaticBlock {
	static {
		System.out.println("此处，可执行类的初始化工作！");
	}
	public static void main(String[] args) {
		System.out.println("main方法中的第一句");
	}
}

4. 课堂demo【重点掌握】

package netclass02;

/**
 * @Auther: Yu Panpan
 * @Date: 2022/1/7 - 01 - 07 - 15:34
 * @Description: netclass02
 * @version: 1.0
 */

/*
 * 代码块：  使用{}括起来的一段代码叫做代码块
 * 分类：
 *   普通代码块:  定义在方法中，使用{}括起来的代码叫做普通代码块
 *   构造代码块：定义在类中的使用{}括起来的代码叫做构造代码块
 *           注意：每次代码运行的时候会将构造代码块中的代码添加到构造方法的前面
 *                   构造代码块中的代码会添加到每一个构造方法中，当使用this(参数)的时候不会添加
 *   静态代码块：使用static{}括起来的代码叫做静态代码块，在程序载入的时候优先执行
 *           数据库连接等其他提前需要准备好的代码会放在static代码块
 *   同步代码块：
 *           在使用多线程的时候会使用，用来给共享空间进行加锁操作（后面讲）
 *   执行顺序：静态代码块--》构造代码块（创建对象的时候才会用到）--》普通代码块
 */
public class CodeBlockDemo {

    int x;
    int y;

    {
        System.out.println("构造代码块");
    }

    static{
        System.out.println("static代码块");
//        x = 100;
    }

    public CodeBlockDemo(){

    }
    public CodeBlockDemo(int x){
        System.out.println("CodeBlockDemo(int x)被执行了");
        this.x = x;
    }
    public CodeBlockDemo(int x,int y){
        this(x);
        System.out.println("CodeBlockDemo(int x,int y)被执行了");
//        this.x = x;
        this.y = y;
    }
    public void test1(){
        System.out.println("test1方法被执行");
        {
            System.out.println("test1方法中的普通代码块");
        }
    }

    public synchronized void test2(){
    //定义一个同步代码块(先见个面，讲到多线程的时候再详细讲。)
//        synchronized(this){
//
//        }
    }

    public static void main(String[] args) {
        CodeBlockDemo cbd = new CodeBlockDemo();
        cbd.test1();
        {
            System.out.println("main方法中的普通代码块");
        }
        CodeBlockDemo cbd2 = new CodeBlockDemo(1,2);
    }
}

四、package
1.为什么需要package?
·为了解决类之间的重名问题。
·为了便于管理类：合适的类位于合适的包
2.package怎么用?
·通常是类的第一句非注释性语句。
·包名：域名倒着写即可，再加上模块名，并不内部管理类。
3.注意事项：
·写项目时都要加包，不要使用默认包。
·com.tensent和com.tensent.oa，这两个包没有包含关系，是两个完全独立的包。只逻辑上看起来
·后者是前者的一部分。
4.JDK中的主要包
·java.lang
·包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
·java.awt
·包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用·程序的图形用户界面(GUI)。
·java.net
·包含执行不网络相关的操作的类。
·java.io
·包含能提供多种输入/输出功能的类。
·java.util
·包含一些实用工具类，如定义系统特性、使用不日期日历相关的函数。
5. 课堂demo【重点掌握】
 

package netclass02;

import java.util.Date;
import java.util.Scanner;

/**
 * @Auther: Yu Panpan
 * @Date: 2022/1/7 - 01 - 07 - 16:24
 * @Description: netclass02
 * @version: 1.0
 */

/*
 * package:包，对应到文件系统就是多级目录
 *   为了解决两个问题：
 *       1、文件同名问题
 *       2、为了方便管理类，将具体处理功能的代码放到同一个目录下
 *   使用：
 *       一般定义package会放置在java文件的第一行
 *           package 域名的倒写
 *              比如：www.taobao.com
 *              包名：com.taobao.
 *           package com.tensent.项目名称
 *         包名的命名规则：
 *                 企业性质.企业名称.项目名称.模块名称. 子模块名称....
 *                      企业性质:com  org  edu gov
 *                      企业名称：alibaba  baidu huawei  tensent
 *                      项目名称：oa  erp  hrms  crm
 *                      模块名称：ums--userManagementSystem   用户管理系统
 *                               oms--orderManagementSystem  订单管理系统
 *                               pms--productManagementSystem 产品管理系统
 *           完整的包名：com.alibaba.taobao.ums/com.alibaba.taobao.oms
 *   完全限定名： 包名+类名
 *
 *   JDK中常用的包：
 *       lang：不需要手动导入，自动加载
 *       awt： 包含了一些GUI图形界面常用的类（这个现在已经不用了，了解即可）
 *       util: 工具包
 *       net: 网络包
 *       io: 输入输出流包
 *
 */
public class PackageDemo {

    public static void main(String[] args) {
//        java.util.Date date = new java.util.Date();
//        java.util.Scanner scanner = new java.util.Scanner(System.in);

        Date date = new Date();
        Scanner scanner = new Scanner(System.in);

//        System.out.println(Math.random());
//        System.out.println();
    }
}

五·import
1.为什么需要import?
如果不使用import，我们如果用到其他包的类时，只能这么写：java.util.Date，代码量太大，不利于编写和维护。通过import可以导入其他包下面的类，从而可以在本类中直接通过类名来调用。

2.import怎么使用?
import java.util.Date;
import java.util.*; //导入该包下所有的类。会降低编译速度，但不会降低运行速度。
3.注意要点：
java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。
如果导入两个同名的类，只能用包名+类名来显示调用相关类：
java.util.Date date = new java.util.Date();

4.import static
静态导入的作用：用于导入指定类的静态属性
JDK5.0后增加！

.如何使用：
import static java.lang.Math.*;//导入Math类的所有静态属性
import static java.lang.Math.PI;//导入Math类的PI属性
然后，我们可以在程序中直接使用：System.out.println(PI);
5. 课堂demo【重点掌握】

package netclass02;

import static java.lang.Math.*;
/**
 * @Auther: Yu Panpan
 * @Date: 2022/1/7 - 01 - 07 - 16:46
 * @Description: netclass02
 * @version: 1.0
 */

/*
 * import:
 *   当需要引入非lang包的其他java类的时候，需要使用import工具
 *       如果不使用import，每次在使用某个类的时候必须要将类的完全限定名都加上才可以使用，太过于繁琐
 *
 *   用法：
 *       import java.包名.类名；导入具体的类  推荐使用
 *       import 包名.*;    将当前包下的所有类文件都进行导入,不推荐，因为它不会影响运行速度，但是会影响编译的速度
 *   注意：
 *       当一个java文件中需要使用多个同名的类的时候，只能选择导入一个，另一个使用完全限定名的方式进行导入
 *
 *   静态导包：
 *       当需要使用某个类的多个方法的时候，同时又不想频繁写该类的名称，此时可以使用静态导包
 */

public class ImportDemo {

    public void abs(){
    }
    
    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);

//        java.util.Arrays.sort(new int[]{1,3,5,4,2});

        //使用netlclass01中的Person类
//        Person person = new Person();

//        Date date = new Date();

//        long time = 12332423;
//        java.sql.Date date1 = new java.sql.Date(time);

//        System.out.println(Math.random());
//        System.out.println(Math.sqrt(4));
//        System.out.println(Math.abs(-2));

        //静态导包可以省略类名
        System.out.println(random());
        System.out.println(sqrt(4));
        System.out.println(Math.abs(-10));
    }
}

六、封装

1. 为什么要使用封装
   下面代码有什么缺陷？

   Dog d = new Dog();
   d.health = -1000;//属性随意访问，不合理的赋值
   

   如何解决上面设计的缺陷？—>使用封装

   2.什么是封装
   ·面向对象三大特征之一 ——封装
   —封装的概念
   封装：将类的某些信息隐藏在类内部，不允许外部程序直接访
   问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
   3.封装的好处
   ·隐藏类的实现细节
   ·只能通过规定方法访问数据
   ·方便加入控制语句
   ·方便修改实现
   4.隐藏/封装(encapsulation)
   ·为什么需要封装？封装的作用和含义？
   我要看电视，只需要按一下开关和换台就可以了。有必要了解电视机内部的
   结构吗？有必要碰碰显像管吗？
   我要开车，….
   隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系
   统的可扩展性、可维护性。
   ·我们程序设计要追求“高内聚，低耦合”。
   高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；
   低耦合 ：仅暴露少量的方法给外部使用。
   5.如何使用封装
   ·封装的步骤