javase笔记_链式调用setter好吗-CSDN博客

本文链接：https://blog.csdn.net/Burn_/article/details/94589221

本文深入探讨Java中的封装与继承概念，讲解如何隐藏类的实现细节，提供公共访问方式，增强代码的安全性和可维护性。同时，分析继承的机制，包括方法重写、super关键字的使用、继承的传递性以及Object类的重要性。

摘要由CSDN通过智能技术生成

第八章

第九章

1.封装

隐藏了类的实现细节，对外提供公共的访问方式。
好处：

安全性
用户只能用我提供的访问方式来访问
方法中可以使用流程控制语句来控制赋值的准确性。

1.封装

第十章访问权限

构造方法也可以调用:
调用本类构造器，必须用-this();-语句；
位置:必须写在构造器中；
必须是构造的第一行代码处。
在这里插入图片描述

class WebUser{
	private int userId;
//	private String userPwd = "999999";
	private String userPwd;
	private String userEmail;	
	public WebUser() {
		this.userPwd = "999999";
	}	
	public WebUser(int userId, String userEmail) {
		//调用带参数的构造
		this(userId,"999999",userEmail);
		
//		this();//调用本类构造器
//		this.userId = userId;
//		this.userEmail = userEmail;
//		this.userPwd = "999999";
		
	}
	public WebUser(int userId, String userPwd, String userEmail) {
		this.userId = userId;
		this.userPwd = userPwd;
		this.userEmail = userEmail;
	}
}

创建对象链式调用setter访问器

	public int getUserId() {
		return userId;
	}
	//     将void改为当前类名，return this;(返回一个对象值)
	public WebUser setUserId(int userId) {
		this.userId = userId;
		return this;
	}
public class TestWebUser {

	public static void main(String[] args) {
		//模板  对象名  创建了一个新的对象    链式调用setter访问器               
		WebUser user = new WebUser().setUserEmail("user@qq.com").setUserPwd("123456").setUserId(222);
		
//		user.setUserId(11);
//		user.setUserEmail("aa@qq.com");
		System.out.println(user.show());
		WebUser user1 = new WebUser().setUserId(111);
		System.out.println(user1.show());
	}
}

1.包解决的问题

在这里插入图片描述
程序包：用来管理类和接口的工具，是类和接口的集合。

1.1创建

定义程序包：
package 包名;
package 父包名.子包名[.……]；
注意：
1.通常包名都用小写字母；
2.位置必须在java文件的第一行代码处；
3.只能有一行 package语句；
4.同一个项目下包名不能重复。
通常：域名反转.部门名.项目名；

1.2使用

同一个程序包下：直接使用；
不同的程序包下：

导入程序包下的类型：

import a.A  //导入类
import a.*   //导入a所有的类型，不包括子包下的类型

完全限定名称的方式：

//如果导入包后，两个包下有同名类，可用完全限定的方式区分
a.A a = new a.A();//可能用的次数不多，或者用于区分 必须用完全限定的方式区分开。

在这里插入图片描述
优点：
1.方便查找；
2.避免命名冲突（与计算机文件相识）；
3.更好的提供了封装。

2.访问修饰符

在这里插入图片描述
private：只能在本类中访问，可见性最低，其它类不能访问
默认：相同程序包下可以访问（不同程序包就不可见，不能访问）
protected：本类、同程序包、子类可见。
public：可见性最高，任何地方都可以访问

3.static（静态）:修饰符

静态：修饰类，成员变量，成员方法，代码块

3.1静态变量

在这里插入图片描述

class Student{
	int count = 0;
}
public class TestStudent {
	public static void main(String[] args) {
		Student guojing = new Student();
		guojing.count ++;
		Student huangrong = new Student();
		huangrong.count ++;
		System.out.println(guojing.count);//1
		System.out.println(huangrong.count);//1
	}
}

在这里插入图片描述

class Student{
	static int count = 0;//静态变量-归类所有（声明处初始化）
}
public class TestStudent {
	public static void main(String[] args) {
		//类名.静态变量名（可以不创建对象）
		Student.count ++;
		Student.count ++;
		System.out.println(Student.count);
    }
}

总结静态变量：

名称：静态变量（类变量）;
属于类，不属于对象；
在类加载时开辟空间，初始化；
优先于对象而存在的；
被所有对象所共享（对象都能用）。

使用语法：
类名.静态变量名; //常用方式
对象名.静态变量名//容易混淆
场合：共享空间的时候用。

静态变量（静态成员） static int count = 0；	成员变量（实例成员）int count = 0；
属于类（共享的）	属于对象
类加载的时候初始化，存在方法区中（先有类然后才能用）	对象创建new时初始化,存在堆中
类卸载的时候（应用程序结束），被释放	对象销毁的时候，被释放

3.2静态方法

在这里插入图片描述

package cn.hn.day0704;

public class TestStaticMethod1 {
	int n = 11;
	static int sn = 22;
	//实例成员方法
	public void f() {
		System.out.println("f");
		System.out.println(n);
		System.out.println(sn);//使用静态成员
	}
	//静态方法（类方法）
	public static void sf() {
		System.out.println("sf");
		//静态方法中只能直接访问静态成员
		System.out.println(sn);
		//非静态的要创建对象访问
		System.out.println(new TestStaticMethod1().n);
		//不能使用this,super
	}
	public static void main(String[] args) {
		TestStaticMethod1.sf();//调用静态方法的常用方式
		new TestStaticMethod1().sf();//
		new TestStaticMethod1().f();
	}
}

静态方法（类方法）:
场合:
1.当类不能创建对象，想实现功能的时候，调用静态方法实现；
2.简单。

静态方法static（调用：类名.方法名；）	成员方法（实列方法）
只能直接访问静态变量（非静态的创建要对象访问）	可以直接访问静态的和非静态的变量
不能使用this,super（没有对象）	可以使用this,super

3.3静态代码块

在这里插入图片描述
代码块：
1）构造块

class 类{
      {
        //构造块：初始化对象的。
      }
  }

2）静态块
静态块是加载类的时候自动执行的

static {
     //静态块:初始化类
}

package cn.hn.day0704;
class Demo{
	static{
		System.out.println("Demo的静态块");
	}
	{
		System.out.println("构造块");
	}
	Demo(){
		System.out.println("构造器");
	}
}
public class TestStaticMethod2 {//启动类，主类
/*	static {
		System.out.println("静态块");
	}*/
	public static void main(String[] args) {
		Demo demo = new Demo();//引起了类的加载
		Demo demo1 = new Demo();//类不会重复加载
//		ClassLoader.getSystemClassLoader().loadClass(name)//了解以下原码
	}
}

静态变量初始化：
在这里插入图片描述

class Demo1{
	static int sn = 11;
	static {
		sn = 22;
	}
}
public class TestStaticMethod3 {
	public static void main(String[] args) {
		System.out.println(Demo1.sn);//22
	}
}

3）局部代码块

public void 方法名（）{
   {
    //局部块：
    //限制 局部变量的使用范围和生命周期。
   }
}

public void f() {
		int n = 11;
		System.out.println(n);
		//局部块
		{
			int m = 22;
			System.out.println(m);
		}
	}

4.静态变量初始化

5.静态导入

格式：
import  static 包名.类名.静态变量名（方法）；

在这里插入图片描述

6.单列模式

只能创建一个对象

//饿汉式
/*
特点：
   1.这个对象类加载时就加载了，就有了；
   2.线程安全的。
*/
class Window{
	 //静态变量只初始化一次
	 private static Window win = new Window();
	 static {
		 System.out.println("static");
	 }
	 private Window(){}
	 public static  Window getWindow() {
		 return win;
	 }
}

第十一章

Math

在这里插入图片描述

		//返回大于等于 45.78的最小整数的double形式
		System.out.println(Math.ceil(45.78));//46.0
		//返回小于等于45.78的最大整数的double形式
		System.out.println(Math.floor(45.78));//45.0
		//四舍五入为一个整数long
		System.out.println(Math.round(45.78));//46
		//（底数，指数） - 》 double
		System.out.println(Math.pow(2, 3));//8.0

Random类随机数：

//		double n = 自动生成：
		double n = Math.random();
		//小数： [0.0 , 1.0）
		System.out.println(n);
		//
//		System.out.println((int)(n*10));// 0 -9
		// [最小值 ，最大值]
		// (int)(Math.random*(最大值-最小值+1) + 最小值)'

Random类随机数：

System.out.println("--------------------------------");
		//位于 util包下
		Random rd = new Random();
		// [0.0 , 1.0)
		System.out.println(rd.nextDouble());
		//int范围内的
		System.out.println(rd.nextInt());
		// [0,上限) 随机整数
//		System.out.println(rd.nextInt(上限));
		System.out.println(rd.nextInt(9));
		
		//----------------------------------------------------
		System.out.println("-----------种子----------------");
		//                   随机种子
//		Random rd1 = new Random(6);
//		Random rd2 = new Random(6);
//		System.out.println(rd1.nextDouble());
//		System.out.println(rd2.nextDouble());
		Random fd3 = new Random();
		System.out.println(fd3.nextDouble());

1.继承

继承：类和类之间的关系，模块和模块之间的关系
派生出新继承：根据已有的类类的技术。
Java支持单一继承。

//编写父类
class 父类{
		//公共的属性和方法
}
//编写子类，继承父类
class 子类 extends 父类{
		//子类特有的属性和方法
}

继承：子类可以继承父类中的功能，就像是在自己的类中定义的一样使用。
注意：不能继承的：

父类中私有的成员。
父类和子类不在同包，父类中默认访问权限的成员；
构造方法。
里氏替换原则：子类是父类，子类可以完全替换掉父类。

在这里插入图片描述
继承的好处：

代码重用
程序的维护（高耦合）

2.方法重写

子类重写（覆盖）了父类的方法

子类中
实例成员方法
方法名必须相同
参数列表必须相同（特殊：父类擦除后与子类相同）
返回值类型相同（特殊：可以是弗雷德子类型）
访问权限不能比父类跟严格（更低）
异常处理不能比父类范围更大

class Parent{
    public void f() {
        System.out.println("Parent_f");
    }
}
class Child extends Parent{
    @Override
    public void f() {
        System.out.println("Child_f");
    }
}

3.super

super:调用父类的成员。
父类和子类方法同名，super区分；
super()调用父类构造的。
每个构造方法中都有隐藏super语句
注意：位置：子类构造中；
子类构造中的第一行代码处。
创建子类对象时，一定会先调用父类构造，然后再调用子类构造。
子类构造中没有显示的super()或this()，那么编译器一定会自动生成一个super()调用父类的构造。
父类中只显示定义了带参构造，那么子类构造器中必须显示调用
super(参数)父类的带参构造。（特殊）
在这里插入图片描述

4.继承传递性

子类可以继承直接父类和间接父类的功能
super调用的是extends直接父类的

class Greandpa{ // Object类
	String name;
	public Greandpa() {
		super();// Object类的构造
	}
	public void eat() {
		System.out.println("吃粥");
	}
}
class Father extends Greandpa{
	String hobby;
	
	public Father() {
		super();
	}
	public void eat() {
		System.out.println("吃米饭");
	}
}
class Son extends Father{
	String tattoo;
	public Son() {
		super();
	}
	public void eat() {
		System.out.println("吃馒头");
	}
	public void show() {
		super.eat();//?
	}
}
public class TestOverrid3 {
	public static void main(String[] args) {
		Son son = new Son();
		son.show();
	}
}

5.Object类

在这里插入图片描述
Object 类：

第十二章抽象类和接口

1.final 常量

修饰：
类：不能被继承
方法：不能被子类重写
变量：常亮，值不能改
//引用类型：对象和数组不能改，属性和值可以改
命名规范： 单词的所有字母都大写，多个单词组成，用下滑线连接
常量的好处：

提高了安全性；
提高了可维护性；
提高了可读性；

final double PI = 3.1415926;
		double s = PI * 4 * 4;
		System.out.println(s);
		//引用：
		final Demo1 demo1 = new Demo1();
		demo1.value = 23;//对象的属性值可以改
//		demo1 = new Demo1();// 对象不能改
		//引用：
		final int [] arr = new int [3];// 0,0,0
		arr[0] = 11;
//		arr = new int[4];

设计可以被继承的类：

提供一个详细的文档说明
继承的层次（通常2-3层）
封装：
隐藏细节

2.实现关系

组合：体现的整体和局部的关系，不是父类与子类的关系
语法：局部类作为整体类的成员变量；

package cn.day0706;
//发动机类
class Engine {
	public void atart() {
		System.out.println("启动发动机！");
	}
	public void stop() {
		System.out.println("停止发动机！");
	}
}
//轮子类
class Wheel{	
}
//车窗类
class Window {
	public void rooIup() {
		System.out.println("升窗！");
	}
	public void roolDoen() {
		System.out.println("降窗！");
	}
}
//车门类
class Door{
	Window window = new Window();
	
	public void open() {
		System.out.println("开门！");
	}
	public void close() {
		System.out.println("关门！");
	}
}
class Car{
	Engine engine;
	Wheel [] wheel;
	Door [] door;
	{
		engine = new Engine();
		wheel = new Wheel[4];
		for (int i = 0; i < wheel.length; i++) {
			wheel[i] = new Wheel();
		}
		door = new Door[2];
		for (int i = 0; i < door.length; i++) {
			door[i] = new Door(); 
		}
	}
}
public class TestCar {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
			Car car = new Car();
			car.door[0].window.rooIup();
			car.door[1].window.roolDoen();
			car.door[0].open();
			car.door[1].close();
			car.engine.atart();
			car.engine.stop();
	}
}

//局部类
class Heart{
	public void beat() {
		System.out.println("心跳");
	}
}
//整体类
class Wolf1{
//	Heart heart = new Heart();
	private Heart heart = new Heart();
	public void beat() {
		heart.beat();
	}
	public void run() {
		System.out.println("跑");
	}
}
public class TestAnimal1 {
	public static void main(String[] args) {
		Wolf1 wolf = new Wolf1();
		wolf.beat();
//		wolf.heart.beat();
		wolf.run();
	}
}

3.抽象（类）（方法）

抽象类： 只定义了类的抽象行为，并没有具体实现相应的行为
语法： abstract class 类名
抽象方法：public abstract void run();（没有大括号）
在这里插入图片描述
注意：

抽象类不能创建对象；
抽象类中的抽象方法可有可无；
普通的子类必须重写实现抽象父类中的所有抽象方法（抽象子类除外）；
构造方法不能是抽象的；
抽象不能private static final一起使用；

//抽象类
abstract class TrafficTool{
	private int count;
	public TrafficTool() {
	}
	public TrafficTool(int count) {
		this.count = count;
	}
	public int getCount() {
		return count;
	}
	public  abstract void run() ;//抽象方法
}
class Car1 extends TrafficTool{	
	public Car1(int count) {
		super(count);
	}
	public void run() {
		System.out.println("汽车在 公路上行驶,载客量：" + getCount() );
	}
}
class Tube extends TrafficTool{
	public void run() {
		System.out.println("地铁在隧道里行驶");
	}
}
public class TestTrafficTool {
	public static void main(String[] args) {
//		TrafficTool tool = new TrafficTool() ;//不能创建对象 
		Car1 car = new Car1(20);
		car.run();
//		Tube tube = new Tube();
//		tube.run();
	}
}

抽象方法的功能

4.接口类-实现类

接口：一组规则的封装。
语法：
在这里插入图片描述
注意：
1）成员都是 public的；
2）常量：public static final
3) 抽象方法：public abstract的
4)默认方法： public default

接口特点：

不能创建对象；
使用通过实现类来使用的；
实现类实现接口，必须实现所有的抽象方法；
实现类可以实现多个接口的功能；
接口之间可以继承，可以多继承。

package cn.day0706;
interface Letter{
	public abstract void writeHeader();
	public abstract void writeBody();
	public abstract void writeFooter();
}
class Jiashu implements Letter {
	@Override
	public void writeHeader() {
		System.out.println("亲爱的父母");
	}
	@Override
	public void writeBody() {
		System.out.println("\t我在北京一切都好!");
	}
	@Override
	public void writeFooter() {
		System.out.println("\t\t\t小明 2019-07-06");
	}
}
public class TestDemo1 {
	public static void main(String[] args) {
		Jiashu jiashu = new Jiashu();
		jiashu.writeHeader();
		jiashu.writeBody();
		jiashu.writeFooter();
	}
}

//三项电
interface ThreeElectric{
	void threeService();//抽象方法
}
//两项电
interface TwoElectric{
	 void twoService();
}
//插排
interface Socket extends ThreeElectric,TwoElectric{
	void socketService();//插排供电
}
class Goods{
	//商品
}
class Computer extends Goods implements Socket{
	@Override
	public void twoService() {
		System.out.println("计算机的外部设备两项电通电");
	}
	@Override
	public void threeService() {
		System.out.println("计算机本身三项电通电");
	}
	@Override
	public void socketService() {
		System.out.println("计算机连接插排供电");
	}
}
/*class Computer implements ThreeElectric,TwoElectric{
	@Override
	public void twoService() {
		System.out.println("计算机的外部设备两项电通电");
	}
	@Override
	public void threeService() {
		System.out.println("计算机本身三项电通电");
	}
}*/

public class TestElectric {

	public static void main(String[] args) {
		Computer computer = new Computer();
		computer.threeService();
		computer.twoService();
//		IceBox box = new IceBox();
//		box.threeService();
	}
}

class IceBox implements ThreeElectric{
	@Override
	public void threeService() {
		System.out.println("冰箱三项电通电");
	}	
}

示例二

interface Info{
	double PI = 3.14;// public static final 
	void af();//public abstract 
	//默认方法 
	default void df() {
		System.out.println("df");
	}
	//接口中的静态方法:不能被子接口和实现类继承
	static void sf() {
		System.out.println("sf");
	}
}
class DemoImplInfo implements Info{
	public void show() {
		System.out.println(PI);
		df();
		Info.sf();
	}
	@Override
	public void af() {
	}
}

实例三

interface IA{
	int N = 11;//常量 static final 
	static void sf() {System.out.println("ia_sf");}
	default void df() {System.out.println("ia_df");}
	void af();
}
interface IB{
	int N = 22;//常量
	static void sf() {System.out.println("ib_sf");}
	default void df() {System.out.println("ib_df");}
	void af();
}
class DemoIAIB implements IA,IB{
	/*//匿名内部类分别是实现的
	IA ia = new IA() {
		@Override
		public void af() {
			System.out.println("ia_af");
		}
	};
	IB ib = new IB() {
		@Override
		public void af() {
			System.out.println("ib_af");
		}
	};
	*/
	@Override
	public void af() {
		System.out.println("af");
	}
	public void show() {
		System.out.println(IA.N);
		System.out.println(IB.N);
		IA.sf();
		IB.sf();
//		df();
	}
	@Override
	public void df() {
		IA.super.df();
		IB.super.df();
		System.out.println("hello");
	}
}

5.多态 07-08

特征：
1.要有方法重写；
2.父类引用指向子类的对象 (子类独特的特征和行为不能使用。)
接口引用指向实现类的对象 (实现类独特的特征和行为不能使用。)
多态的特点：
1.对于成员变量来说（在编译的时候是看左边的，运行的时候也是看左边的）
2.对于成员方法来说（在编译的时候是看左边的，运行是看右边的）
1、针对多态，父类型的引用指向子类对象，Aniam aniam = new Cat();
2、多态在执行方法的时候，首先去看父类中是否存在这个方法；
a.如果没有，编译器直接报错；
b.如果有就去找子类的方法；
b1.如果子类有，就相当于把父类的方法给覆盖了，那么就直接调用子类的方法；
b2.如果子类没有，相当于是从父类上继承下来了，相当于是调用了父类的方法
3、父类型的引用指向子类对象，调用的方法是实际指向的对象；

package cn.day0708;
abstract class Vehicle{
	public abstract void run();
}
class Car extends Vehicle{
	public void run() {
		System.out.println("汽车行驶中……！");
	}
}
class Metro extends Vehicle{
	public void run() {
		System.out.println("地铁行驶中……！");
	}
}
class People{
	private String name;
	People (String name){
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void go(Vehicle veh) {
		System.out.println("员工"+this.name+"回家了！");
		veh.run();
	}
}
public class TestHome {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		People people1= new People("爱编程");
		Car car = new Car();
		people1.go(car);
		People people2= new People("爱学习");
		Metro metro = new Metro();
		people2.go(metro);
	}
}

应用

类

class Base{
	int n;
	public void f() {
		System.out.println("base_f");
	}
}
class Sub1 extends Base{
	int m;
	public void f() {
		System.out.println("sub1_f");
	}
	public void method() {
	}
}
class Sub2 extends Base{
	int x ;
	public void f() {}
	public void function() {}
}
public class TestDemo {
	public static void main(String[] args) {
		Base sub1 = new Sub1();
		sub1.f();
		System.out.println(sub1.n);
		//多态:子类独特的特征和行为不能使用。
//		sub1.method();
    }
}

接口

interface Info{
	public void af();
}
class InfoImpl1 implements Info{
	public void af() {
		System.out.println("info1 _ af");
	}
	public void ff() {}
}
public class TestInfo {
	public static void main(String[] args) {
		Info info1 = new InfoImpl1();
		info1.af();
		//多态：实现类独特的特征和行为不能使用。
//		info1.ff();
	}
}