Java自学笔记Day09

其他 2019-03-28 23:34:35 阅读次数: 0

Day09

代码块的概述和分类

/*
A:代码块概述
	*在java中,使用{}括起来的代码被称为代码块;
B:代码块分类
	*根据其位置和声明的不同,可以分为局部代码块,构造代码块,静态代码块,同步代码块(多线程理解);
C:常见代码块的应用
	a:局部代码块
		*在类方法中出现,限定变量周期声明周期,及早释放,提高内存效率;
	b:构造代码块(初始化块)
		*在类方法外出现,多个构造方法中相同的代码存放在一起,每次调用构造都执行,并且在构造方法前执行;
	c:静态代码块
		*在类中方法外出现,加了static修饰;
		*在类中方法外出现,并加了static修饰;用于给类进行初始化,在加载的时候执行,并且只能执行一次;
		*一般用于加载驱动;
*/
class Demo1_Code  {
	public static void main(String[] args) {
		{
			int x = 10;							 //限定变量的声明周期;
			System.out.println(x);
		}

		Student s1 = new Student();
		System.out.println("------------");
		Student s2 = new Student("李四",23)	;
		System.out.println("------------");
		Student s3 = new Student("李四",23)	;
		System.out.println("------------");
		Student s4 = new Student("李四",23)	;


	}

	static {
		System.out.println("我是在主方法中的代码块");	//静态代码块,优先于主方法执行
}
class Student {
	private String name;
	private int age;

	public Student(){							 //空参构造
		System.out.println("空参构造");
	}

	public Student (String name, int age){		 //有参构造
		this.name = name;
		this.age = age;
		System.out.println("有参构造");
    }
	public void setName (String name ){
		this.name = name ;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}

	{									//构造代码块:每创建一次对象就执行一次,优先于构造函数执行
		//System.out.println("构造代码块");
		study();
	}
	public void study(){
		System.out.println("学生学习");
	}
	static {									  //随着类的加载而加载,而且只执行一次
		System.out.println("我是静态代码块");		 //作用给类进行初始化,一般用来加载驱动														 //静态代码块优先于主方法执行;
	}
}
 
    //案例演示
   class Demo2_Student  {
	static {
			System.out.println("Demo2_Student静态代码块");
		}
	public static void main(String[] args) {
		System.out.println("我是主方法");
		Student s1 = new Student();
		Student s2 = new Student();
	}
}													
class Student {
	static {
		System.out.println("Student静态代码块");
	}
	{
		System.out.println("Student构造代码块");
	}
	public Student(){
		System.out.println("Student构造方法(空参构造)");
	}
}

继承

继承的概述

/*A:继承(extends)
	*让类与类之间产生关系,子父类关系; 作用:通过继承拿到父类的属性和方法
 B:继承案例演示
 	*动物类,毛类,狗类
 	*定义两个属性(颜色,腿的个数)两个功能(吃飯,睡觉);
 C:案例演示:使用继承前;
 D:案例演示,使用继承后;
 */
class Demo1_Extends  {
	public static void main(String[] args) {
		Cat c = new Cat();
		c.color = "花" ;
		c.leg = 4;
		c.eat();
		c.sleep();

		System.out.println("猫是一只" + c.color + "猫" + ",腿的个数是" + c.leg +"个");
	}
}
/*A:继承(extends)
	*让类与类之间产生关系,子父类关系;
 B:继承案例演示
 	*动物类,毛类,狗类
 	*定义两个属性(颜色,腿的个数)两个功能(吃飯,睡觉);
 C:案例演示:使用继承前;
 D:案例演示,使用继承后;
 */
 //继承前
class Cat extends Animal {
	/*String color;			  //动物的颜色;
	int leg;				  //动物腿的个数;
	public void eat(){
		System.out.println("吃飯");
	}						  //吃飯的功能;
	public void sleep(){
		System.ouy.println("睡觉"):
	}*/						  //睡觉的功能
}
class Dog extends Animal {
	/*String color;			  //动物的颜色;
	int leg;				  //动物腿的个数;
	public void eat(){
		System.out.println("吃飯");
	}						  //吃飯的功能;
	public void sleep(){
		System.ouy.println("睡觉"):
	}	*/					  //睡觉的功能
}
//继承后
class Animal {
	String color;			  //动物的颜色;
	int leg;				  //动物腿的个数;
	public void eat(){
		System.out.println("吃飯");
	}						  //吃飯的功能;
	public void sleep(){
		System.out.println("睡觉");				
	}						  //睡觉的功能
}
/*extends 是继承;
Animal是父类;
Cat和Dog是子类;
通过继承,子类拿到了父类的方法和属性
*/

继承的好处与弊端

A: 继承的好处:
	*提高了代码的复用性;
	*提高了代码的维护性;(父类增加属性和方法,子类便会继承);
	*让类与类产生关系,是多态的前提;
B: 继承的弊端:
	*提高了代码的耦合性;(父与子的关系太密切);
	*开发的原则:高内聚,低耦合
		*耦合:类与类的关系;
		*内聚:就是完成某件事情的能力;

类的继承特点:

/*
 *A: java中类的继承特点:
	*a:Java中只支持单继承,不支持多继承(一个儿子只能有一个爹);
		有语言是支持多继承,格式:extends 类1,类2;
	*b:	Java中支持多层继承

	*b:	案例演示;
		*Java中类的继承特点:
			*如果想用这个体系的所有功能用最底层的类创建对象;
			*如果想看这个提醒的共性功能,看最顶层的类;
*/
class Demo2_Extends  {
	public static void main(String[] args) {
		DemoC c = new DemoC();
		c.show();
	}
}
class DemoA {									 //最顶层的
	public void show(){
		System.out.println("Demo_A");
	}
}
/*
class DemoB {
	public void show(){
		System.out.println("Demo_B");
	}
}
class DemoC extends DemoA,DemoB{};		  //不支持多继承;多继承存在安全隐患
 */
 class DemoB extends DemoA {
	 public void show(){
		System.out.println("Demo_B");
	 }
 }
class DemoC extends DemoB {
	 public void show(){
		System.out.println("Demo_C");
	 }
 }

继承的注意事项和使用环境

/*
A:继承的注意事项
	a:子类只能继承父类的所有非私有成员(成员变量和成员方法);
	b:子类不能继承父类的构造方法,但是可以通过super关键字去访问父类的构造方法;
	c:不要为了不跟功能而选择去继承;
	案例演示:
		*项目经理 姓名 工号 工资 奖金
		*程序员 姓名 工号 工资
B:什么时候使用继承
	*继承其实体现的是一种关系:"is a".
	Person 
		Student 
		Teacher
	水果
		苹果
		香蕉
		橘子
	
	采用假设法
		如果有两个类A,B.只有他们符合A是B的一种,或者B是A的一种,可以考虑继承
*/

继承中成员变量的关系

/*
A:案例演示
	*a: 不同名的成员变量;	 //两个变量都会进行输出
	*b: 同名的成员变量;		 //就近原则
	子父类出现同名只会出现在讲课的例子中,在开发中并不会出现这样的情况;
	子类继承父类就是为了使用父类的成员;如果定义了同名的变量就没有意义了
*/
class Demo4_Extends  {
	public static void main(String[] args) {
		Son s  = new Son();
		s.print();
	}
}
class Father {
	int num1 = 10;
	int num2 = 30;
}
class Son extends Father {
	int num2 = 20;

	public void print(){
		System.out.println(num1);
		System.out.println(num2);		 //就近原则,子类有就不会用父类的
	}
}

this和super的区别

/*
A:this和super各代表什么?
	*this代表当前对象的引用,谁来调用我,我就代表谁;
	*super代表对象父类的引用;
B:this和super的使用区别
	*a:调用成员变量
		*this 成员变量:调用本类的成员变量,也可以调用父类的成员变量;
		*super 成员变量:调用父类的成员变量;
	*b: 调用构造方法
		*this(....) 调用本类的构造方法;
		*super(...) 调用父类的构造方法;
	*c:调用成员方法
		*this.成员方法,调用本类的成员方法;也可以调用父类的成员方法;
		*super.成员方法:调用父类的成员方法;
*/
class Son extends Father {
	int num2 = 20;

	public void print(){
		System.out.println(this.num1);		  //本类没有,就调用父类的
		System.out.println(super.num2);		 //就近原则,子类有就不会用父类的
	}
}

继承中构造方法的关系

/*
A:案例演示
	*子类中所有的构造方法默认访问父类中空参的构造方法;
B:Why?
	*因为子类会继承父类中的数据,可能还会使用父类中的数据;
	*所以子类初始化之前,一定要先完成父类的初始化;
		*其实:
		*每一个构造方法对的第一条语句默认都是:super() Object类最顶层的父类
		*如果不写继承就默认继承Object类
*/
class Demo5_Extends  {
	public static void main(String[] args) {
		Son s = new Son();
	}
}
class Father {
	public Father(){
		System.out.println("Father的构造方法");
	}
}
class Son extends Father {
	public Son(){
		super();		//这是一条语句,如果不写,系统会默认加上.它的作用是:用来访问父类的空参构造;
		System.out.println("Son的构造方法");
	}
}

继承中构造方法的注意事项

/*A:案例演示
	*父类没有无参构造,子类怎么办?
	 *super解决;
	 *this解决;
B:注意事项
	*super(...)或者this(...)必须出现在构造方法的第一条语句上
*/
class Demo6_Extends  {
	public static void main(String[] args) {
		Son s1 = new Son();
		System.out.println(s1.getName() +"------"  + s1.getAge());
		System.out.println("-----------");
		Son s2  = new Son("张三",23);
		System.out.println(s2.getName() +"------"  + s2.getAge());
	}
}
class Father {
	private String name;
	private int age;

	/*public Father(){
	/	System.out.println("Father空参构造");
	} */
	public Father(String name ,int age){  //有参构造
		this.name = name ;
		this.age = age;
		System.out.println("Father有参构造");
	}
	public void setName(String name){
		this.name = name;		//设置姓名;
	}
	public String getName(){
		return name;			//获取姓名
	}
	public void setAge(int age){
		this.age = age;			//设置年龄
	}
	public int getAge(){
		return age;				//获取年龄
	}
}
class Son extends Father {
	public Son(){
		//super("李四",24);	  //调用父类中的有参构造
		this("王五",25);		  //调用本类中的有参构造
		System.out.println("Son的空参构造");
	} 
	public Son(String name,int age){
		super(name,age);
		System.out.println("Son的有参构造");
	}
}
//案例演示
    /*
	1,jvm调用了main方法,main进栈
	2,遇到Zi z = new Zi();会先将Fu.class和Zi.class分别加载进内存,再创建对象,当Fu.class加载进内存
	父类的静态代码块会随着Fu.class一起加载,当Zi.class加载进内存,子类的静态代码块会随着Zi.class一起加载
	第一个输出,静态代码块Fu,第二个输出静态代码块Zi
	3,走Zi类的构造方法,因为java中是分层初始化的,先初始化父类,再初始化子类,所以先走的是父类构造,但是在执行
	父类构造时,发现父类有构造代码块,构造代码块是优先于构造方法执行的,所以第三个输出构造代码块Fu,第四个输出构造方法Fu
	4.Fu类初始化结束,子类初始化,第五个输出的是构造代码块Zi,构造方法Zi
	*/
class Test2_Extends {
	public static void main(String[] args) {
		Zi z = new Zi();
	}
}
class Fu {
	static {
		System.out.println("静态代码块Fu");
	}

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

	public Fu() {
		System.out.println("构造方法Fu");
	}
}

class Zi extends Fu {
	static {
		System.out.println("静态代码块Zi");
	}

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

	public Zi() {
		System.out.println("构造方法Zi");
	}
}

继承中成员方法关系

A:案例演示
	*a:不同命方法;
	*b:同名方法;   // 就近原则
class Demo7_Extends  {
	public static void main(String[] args) {
		Son s = new Son();
		s.print();
		s.method();
	}
}
class Father {
	public void print(){
		System.out.println("Fu print");
	}
	}

class Son extends Father {
	public void print(){
		super.print();
		System.out.println("Zi print");
	}
	public 	void method(){
		System.out.println("Zi method");
	}
}

方法重写

方法重写的概述

/*
A:什么是方法重写?
	重写:子父类出现一模一样的方法(注意:返回值可以是子父类);
B:方法重写的应用:
	*当子类需要父类的功能,而功能主题子类有自己的特有内容时,可以重写父类的方法.这样,即沿袭了父类的功能,又定义了子类特有的内容;
C:案例演示:
	定义一个手机类
*/
class Demo7_Phone  {
	public static void main(String[] args) {
		Ios8 i = new Ios8();
		i.call();
		i.siri();
	}
}

/*
B:方法重写的应用
	*当子类需要父类的功能,而功能主题子类有自己的特有内容时,可以重写父类的方法.这样,即沿袭了父类的功能,又定义了子类特有的内容;
	IOS7系统, siri 只能说英文
	IOS8系统 siri 说中文
*/	 
class Ios7{
	public void	call(){
		System.out.println("打电话");
	}

	public void siri(){
		System.out.println("speak english");
	}
}

class Ios8 extends Ios7 {
	public void siri(){
		super.siri();
		System.out.println("说中文");
	}
}

方法重写的注意事项

/*
A:方法重写的注意事项:
	*a:父类中私有方法不能被重写;
		因为父类中的私有方法无法继承;
	*b:子类重写父类方法时,访问权限不能更低;
		*最好一致;
	*c:父类静态方法,子类也必须通过静态方法进行重写;
		*其实这个算不上重写,但是现象确实如此,至于为什么算不上重写,多态中讲解
		
	*子类重写父类,方法声明最好是一模一样;
B:案例演示
	*方法重写注意事项
*/

方法重写相关的面试题

A:方法重写的相关面试题
	Override和Overload的区别?Overload能改变返回值类型吗?
	*Overload(重载):可以改变返回值类型,只看参数列表;
	*方法重写:子类中出现和父类中方法声明一模一样的方法,与返回值类型有关,返回值是一致的(或者是子父类的)
	
	*方法重载:本类中出现的方法名一样,参数列表不同的方法,与返回值类型无关
	子类对对象调用方法的时候:
		先找子类本身,再找父类;

继承案例演示

//老师和学生类
class Test4_Person  {
	public static void main(String[] args) {
		Student s1 = new Student();
		s1.setName("李四");
		s1.setAge(23);
		System.out.println(s1.getName() + "----------" + s1.getAge());
		s1.eat();
		s1.study();
		System.out.println("----------");
		Student s2 = new Student("张三",24);
		System.out.println(s2.getName() + "----------" + s2.getAge());
		s2.eat();
		s2.study();
	}
}
/*
使用继承后的老师和学生类
*/
class Person {
	private String name;					  //姓名
	private int age;						  //年龄

	public Person(){};						  //空参构造
	public Person(String name,int age){	      //有参构造	
		this.name = name;						   
		this.age = age;							   
	}
	public void setName(String name){		  //设置姓名
		this.name = name ;
	}
	public String getName(){				  //获取姓名
		return name;
	}
	public void setAge(int age) {			  //设置年龄
		this.age = age;
	}
	public int getAge(){					  //获取年龄
		return age;
	}
	public void  eat (){
		System.out.println (name + "吃飯");	  //吃飯
	}
}
class Student extends Person {
	public Student(){};						   //空参构造;
	public Student(String name,int age){       //有参构造
		super(name,age);
	}
	public void study(){
		System.out.println(getName() + "学习");
	}
}
class Teacher extends Person {
	public Teacher(){};						   //空参构造;
	public Teacher(String name,int age){       //有参构造
		super(name,age);
	}
	public void teach(){
		System.out.println("老师讲课");
	}
}

动物,猫狗类
class Test5_Animal  {
	public static void main(String[] args) {
		//猫
		Cat c1 = new Cat();
		c1.setColor("white");
		c1.setLeg(4);
		System.out.println(c1.getColor() + "--------" + c1.getLeg());
		c1.eat();
		c1.catchMouse();
		System.out.println("--------");
		Cat c2 = new Cat("black",4);
		System.out.println(c2.getColor() + "--------" + c2.getLeg());
		c2.eat();
		c2.catchMouse();
		//狗
		System.out.println("--------");
		Dog d = new Dog("花",  4);
		System.out.println(d.getColor() + "--------" + d.getLeg());
		d.eat();
		d.watchDog();

	}
}
class Animal {
	private String color;		//毛的颜色
	private int leg;			//腿的个数

	public Animal(){};			//空参构造
	public Animal(String color,int leg){
		this.color  = color;
		this.leg = leg;
	}							//有参构造
	public void setColor(String color){
		this.color = color;
	}							//设置颜色;
	public String getColor(){
		return color;
	}							//获取毛的颜色
	public void setLeg(int leg){
		this.leg = leg;
	}							//设置腿的个数;
	public int getLeg(){
		return leg;
	}							//设置腿的个数;

	public void eat(){
		System.out.println("吃食");
	}							//动物吃饭;

}
class Cat extends Animal {
	public Cat(){};
	public Cat(String color,int leg){
		super(color,leg);
	}
	public void catchMouse(){
		System.out.println("猫捉老鼠");
	}
}
class Dog extends Animal {
	public Dog(){};
	public Dog(String color,int leg){
		super(color,leg);
	}
	public void watchDog(){
		System.out.println("看家护院");
	}
}

final关键字

/*A:final概述			//String 被final修饰
B:final修饰特点
	*修饰类,类不能被继承;
	*修饰变量,变量就变成了常量,只能被赋值一次;
	*修饰方法,方法不能被重写
C:案例演示
*/
class Demo1_Final  {
	public static void main(String[] args) {
		Son s = new Son();
		s.print();
	}
}
/*final class Father {					// 无法从最终Father进行继承
	public final void print(){
		System.out.println("访问底层资源");
	}
}*/
class Son /*extends Father*/ {
	final int NUM = 10;	//常量命名规范,如果是一个单词,所有字母大写,如果是多个单词,所有字母都大写
	public static final double PI = 3.14;	//修饰变量叫做常量,一般会与public static 共用
	public void print(){
		//int num = 20 ;
		System.out.println(NUM);	
	}
}

final关键字修饰局部变量

/*
*final修饰基本类型 是值不能被改变;
*final修饰引用类型,是地址值不能被改变,对象中的属性可以改变
*/
class Demo2_Final  {
	public static void main(String[] args) {
		final int NUM =10;
		//NUM = 20;
		System.out.println(NUM);

		final Person p = new Person("张三",23);
		//p = new Person("李四",24);
		p.setName("李四");
		p.setAge(24);
		System.out.println(p.getName() + "------" + p.getAge());

		method(10);
		method(20);

	}	 

	public static void method(final int x){
		System.out.println(x);
	}
}
/*
 *A:案例演示
	*方法内部或者声明上都演示一下

	*final修饰基本类型 是值不能被改变;
	*final修饰引用类型,是地址值不能被改变,对象中的属性可以改变
*/
class Person {
	private String name;
	private int age;
	public Person(){};
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}

}

final修饰变量的初始化时机

/*
A:final修饰变量的初始化时机
	 *显示初始化
	 *在对象构造完毕前即可;	(通过构造方法初始化)
*/
class Demo3_Final  {
	public static void main(String[] args) {
		Demo d = new Demo();
		d.print();
	}
}

class Demo {
	final int num;		  //成员变量的默认初始化值是无效值
	//final int num = 10;	  //显示初始化
	public Demo(){
		num = 10;		  //
	}
	public void print(){
		System.out.println(num);
	}
}

猜你喜欢

转载自blog.csdn.net/weixin_43597282/article/details/88640376
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022