javase笔记2019-07-03

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了javase笔记2019-07-03，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含15006字，纯文字阅读大概需要22分钟。

内容图文

javase笔记

• 第八章
• 第九章
• 1.封装
• 1.封装
• 第十章 访问权限
• 1.包解决的问题
• 1.1创建
• 1.2使用
• 2.访问修饰符
• 3.static（静态）:修饰符
• 3.1静态变量
• 3.2静态方法
• 3.3静态代码块
• 4.静态变量初始化
• 5.静态导入
• 6.单列模式
• 第十一章
• Math
• 1.继承
• 2.方法重写
• 3.super
• 4.继承传递性
• 5.Object类
• 第十二章 抽象类和接口
• 1.final 常量
• 2.实现关系
• 3.抽象（类）（方法）
• 4.接口类-实现类
• 5.多态 07-08
• 应用
• 运算符
• 类型转换
• 6.UML之类图

第八章

第九章

1.封装

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

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

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使用

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

1. 导入程序包下的类型：

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

2. 完全限定名称的方式：

                 //如果两个包下有同名类，可用完全限定的方式区分
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);
    }
}

总结静态变量：

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

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

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.简单。

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 父类{
		//子类特有的属性和方法
}

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

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

继承的好处：

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

2.方法重写

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

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

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 常量

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

1. 提高了安全性；
2. 提高了可维护性；
3. 提高了可读性；

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];

设计可以被继承的类：

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

2.实现关系

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

//局部类
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();（没有大括号）

注意：

1. 抽象类不能创建对象；
2. 抽象类中的抽象方法可有可无；
3. 普通的子类 必须 重写实现抽象父类中的所有抽象方法（抽象子类除外）；
4. 构造方法不能是抽象的；
5. 抽象不能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

接口特点：

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

//三项电
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、父类型的引用指向子类对象，调用的方法是实际指向的对象；

应用

类

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();
	}
}

运算符

类型转换

6.UML之类图

内容总结

以上是互联网集市为您收集整理的javase笔记2019-07-03全部内容，希望文章能够帮你解决javase笔记2019-07-03所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端