Java高级类特性（5.25）

最新推荐文章于 2021-03-10 12:52:07 发布
最新推荐文章于 2021-03-10 12:52:07 发布
阅读量506 收藏
点赞数
分类专栏： Java语言高级编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haoge921026/article/details/45973201
版权
1.创建对象时，代码的执行顺序
  [1]初始化父类属性，调用语句块，调用父类的构造
  [2]初始化子类属性，调用语句块，调用子类的构造
  如果父类构造被重载，需要子类来确定具体调用父类中的哪个构造。 
package com;

public class Book {
	protected String name;
	protected int price;
	
	{
		System.out.println("初始化块，载入资源或者是第三方动态库");
	}
	
	
	public Book() {
		// TODO Auto-generated constructor stub
		System.out.println("调用不带参的Book构造方法");
	}
	
	public Book(String name, int price) {
		// TODO Auto-generated constructor stub
		this.name = name;
		this.price = price;
	}
	
	public void printInfo()
	{
		System.out.println(name + ":" + price);
	}
}
package com;

public class ComputerBook extends Book {
	
	public ComputerBook() {
		// TODO Auto-generated constructor stub
		System.out.println("调用ComputerBook构造方法");
	}
}
package com;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		ComputerBook cb = new ComputerBook();
	}
}
2.封装类
  byte     Btye
  short    Short
  int      Integer
  long     Long
  float    Float
  double   Double
  boolean  Boolean
  char     Charactor 
package com;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//在栈区分配内存
		int i = 10;
		
		//在堆上分配内存
		Integer ii = new Integer(10);
		
		//可以将一个含有数字的字符串转化为int型
		int number = ii.parseInt("123");
		System.out.println(++number);
		
		
		Integer i_01 = new Integer(100);
		Integer i_02 = new Integer(100);
		//比地址
		System.out.println(i_01 == i_02);
		
		int ii_01 = 10;
		int ii_02 = 10;
		//比值
		System.out.println(ii_01 == ii_02);
		
		
		//自动装箱
		//Integer i_03 = new Integer(100);  <==> Integer i_03 = 100;
		Integer i_03 = 100;
		
		//自动拆箱
		//int i_04 = new Integer(100); <==> int i_04 = 100;
		int i_04 = new Integer(100);
	}
}

  自动装箱
  Integer ii = 100;


  自动拆箱
  int i = new Integer(100);  


3.Object类中的方法
  [1]toString() 打印输出对象名时调用。可以被子类重写。
  [2]equal()    定义对象相等的含义
  [3]finalize() 在垃圾回收其回收当前生成的对象时调用，用来做清理工作，例如关闭流等。 
package com;

//Alt + ? 提示出当前类所拥有的属性和方法
public class Book {
	
	private String name;
	private int price;
	
	public Book() {
		// TODO Auto-generated constructor stub
		name = "think in java";
		price = 100;
	}
	
	public Book(String name, int price) {
		// TODO Auto-generated constructor stub
		this.name = name;
		this.price = price;
	}
	
	
//	@Override
//	public String toString() {
//		// TODO Auto-generated method stub
//		return name + ":" + price;
//	}
	
	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		
		System.out.println("obj = " + obj);
		System.out.println("this = " + this);
		
		Book book = (Book)obj;
		
		return this.name.equals(book.name) && this.price == book.price;
	}
}
package com;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//toString()----------Object
		Book book = new Book();
		
		//打印输出对象名，是系统调用toString()方法
		System.out.println(book);
		
		String s = book.toString();
		System.out.println(s);
		
		String s_01 = new String("abc");
		String s_02 = new String("abc");
		
		//equal()---------------Object
		//比地址
		System.out.println(s_01 == s_02);
		//比内容
		System.out.println(s_01.equals(s_02));
		
		Book b_01 = new Book("book01", 100);
		Book b_02 = new Book("book01", 100);
		
		System.out.println(b_01.equals(b_02));
		System.out.println("b_02 = " + b_02);
		System.out.println("b_01 = " + b_01);
	}
}
4.static(静态)
  [1]static修饰变量
  [2]static修饰方法
  [3]static修饰语句块--------在第一次创建对象时调用
  [4]static修饰类------------几乎不用，先不管
  
  静态内容在字节码文件载入JVM时，被初始化
  静态内容通过类名调用 
package com;

public class Book {
	
	//在类文件载入虚拟机时，系统对静态数据分配内存空间
	public static int number;
	
	private String name;
	private int price;
	
	static {
		System.out.println("执行静态语句块");
	}
	
	public Book() {
		// TODO Auto-generated constructor stub
		number++;
	}
	
	//最终方法，不能被重写
	public final void printInfo()
	{
		System.out.println(name);
	}
}
package com;

public class ComputerBook extends Book {
	
}
package com;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//统计用户创建了多少本书？
		
		System.out.println(Book.number);
		
		Book book_01 = new Book();
		Book book_02 = new Book();
		Book book_03 = new Book();
		Book book_04 = new Book();
		Book book_05 = new Book();
		
		System.out.println(Book.number);
		
		//静态方法
		Math.random();
	}
}
5.final(最终)
  final修饰变量，表示常量
  final修饰方法，表示该方法不能被重写
  final修饰类，表示该类不能被继承


6.抽象类
  [1]abstract修饰类，为抽象类
     不能创建对象
  [2]abstract修饰方法，为抽象方法
     没有方法体，被子类实现
  [3]如果子类继承一个抽象类，要么实现抽象类中的所有抽象方法，
     要么将子类定义为抽象类

  [4]包含抽象方法的类一定是抽象类。抽象类不一定包含抽象方法。

package com;

//包含抽象方法的类必须定义为抽象类
//抽象类不一定包含抽象方法
public abstract class Shape {
	protected int a;
	protected int b;
	
	public Shape(int a, int b) {
		// TODO Auto-generated constructor stub
		this.a = a;
		this.b = b;
	}
	
	//抽象方法：没有方法体
	public abstract int getArea();
}

package com;

public class Circle extends Shape {

	public Circle(int a, int b) {
		super(a, b);
		// TODO Auto-generated constructor stub
	}

	@Override
	public int getArea() {
		// TODO Auto-generated method stub
		return (int)(Math.PI*a*a);
	}
}
package com;

//子类继承抽象类，需要实现抽象类的抽象方法
//如果子类没有实现父类中所有的抽象方法，那么子类需要定义为抽象类
public class Rect extends Shape{

	public Rect(int a, int b) {
		super(a, b);
		// TODO Auto-generated constructor stub
	}

	@Override
	public int getArea() {
		// TODO Auto-generated method stub
		return a*b;
	}
}
package com;

public class Thriangle extends Shape {

	public Thriangle(int a, int b) {
		super(a, b);
		// TODO Auto-generated constructor stub
	}

	@Override
	public int getArea() {
		// TODO Auto-generated method stub
		return (int)(Math.sin(Math.PI/3)*a*a/2);
	}
}

package com;

public class TRect extends Shape {

	private int h;
	
	public TRect(int a, int b, int h) {
		super(a, b);
		this.h = h;
		// TODO Auto-generated constructor stub
	}

	@Override
	public int getArea() {
		// TODO Auto-generated method stub
		return (a+b)*h/2;
	}
}
package com;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//抽象类不能创建对象
//		Shape shape = new Shape();
//		shape.getArea();
		
		//打印输出所有边为10的形状的面积
		
		Circle c = new Circle(10, 10);
		Rect r = new Rect(10, 10);
		TRect tr = new TRect(10, 10, 10);
		Thriangle tg = new Thriangle(10, 10);
		
		c.getArea();
		r.getArea();
		tr.getArea();
		tg.getArea();
		
		//for
		
		Shape s_01 = new Circle(10, 10);
		
		Shape shapes[] = {new Circle(10, 10), new Rect(10, 10),
				new TRect(10, 10, 10), new Thriangle(10, 10)};
		for (int i = 0; i < shapes.length; i++) {
			shapes[i].getArea();
		}
	}
}
7.接口
  [1]定义格式：
     interface 接口名
     {
静态常量
        抽象方法
     } 
  [2]类可以实现(implements)多个接口
  [3]接口之间可以多继承  
package ppt;

public interface InterUSB {
	public void startWork();
	public void endWork();
}
package ppt;

public class Kindle implements InterUSB {

	@Override
	public void startWork() {
		// TODO Auto-generated method stub
		System.out.println("连接usb，打开电子书");
	}

	@Override
	public void endWork() {
		// TODO Auto-generated method stub
		System.out.println("断开usb， 关闭电子书");
<span style="white-space:pre">	</span>}
}
package ppt;

public class Moble implements InterUSB {

	@Override
	public void startWork() {
		// TODO Auto-generated method stub
		System.out.println("手机连接上USB");
	}

	@Override
	public void endWork() {
		// TODO Auto-generated method stub
		System.out.println("手机断开连接");
	}
}
package ppt;

public class Printer implements InterUSB {

	@Override
	public void startWork() {
		// TODO Auto-generated method stub
		System.out.println("打印机开始工作");
	}

	@Override
	public void endWork() {
		// TODO Auto-generated method stub
		System.out.println("打印机结束工作");
<span style="white-space:pre">	</span>}
}
package ppt;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//启动设备Printer，Moble，Kindle，开始工作
		//工作中
		//关闭设备，停止工作
		Kindle read = new Kindle();
		read.startWork();
		
		Moble phone = new Moble();
		phone.startWork();
		
		Printer penter = new Printer();
		penter.startWork();
		
		read.endWork();
		phone.endWork();
		penter.endWork();
	}
}
8.面向对象的特征
  [1]封装
     封装意味着把对象的属性和方法结合成一个独立的系统单位，
     并尽可能隐藏对象的内部细节。
  [2]抽象
     抽象的过程是对具体问题进行概括的过程，
     是对一类公共问题进行统一描述的过程
  [3]继承
     子类对象拥有其父类相同的全部属性和方法。
  [4]多态
     多态时指在父类中定义的属性和行为被子类继承后，可以具有不同的数据类型或者表现行为等特征


9.多态
  [1]多态的体现
     方法的重载------编译时多态

     方法的重写------运行时多态

  [2]对象的多态性
     向上转型：程序自动完成--------(上溯造型)
     父类 父类的引用 = 子类对象
     向下转型：            --------(下溯造型)
     子类 子类的引用 = (子类)父类的引用
  [3]instanceof类型检测运算符
     在造型前使用instanceof运算符测试对象的类型
  [4]多态的好处
     以多态的形式传递参数，增强了参数类型的灵活性。
  [5]引用数据类型的转换一定发生在父子类之间
     父子关系：
     1.子类 extends 父类
     2.类 implements 接口  ---------类是接口的子类，接口是类的父类

package com;

public class Moble {
	
	
	public void printfInfo()
	{
		System.out.println("这是一台手机");
	}
}
package com;

public class CellMoble extends Moble {
	@Override
	public void printfInfo() {
		// TODO Auto-generated method stub
		System.out.println("这是一部生物手机");
	}
}
package com;

public class SmartMoble extends Moble{

	@Override
	public void printfInfo() {
		// TODO Auto-generated method stub
		System.out.println("这是一台智能手机");
	}
	
	public void buy()
	{
		System.out.println("买一部智能手机");
	}
}
package com;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Moble moble = new SmartMoble();
		moble.printfInfo();
		
		//基本数据类型的转换
		int i = (int)2.0;
		//引用数据类型的转换
		//父类型强制转换为子类型
		
		//将父类型引用(moble)强制转换为子类型引用(smartMoble)
		System.out.println(moble);
		SmartMoble smartMoble = (SmartMoble)moble;
		System.out.println(smartMoble);
		smartMoble.buy();
		
		Moble moble02 = new CellMoble();
		//类型转换错误
		SmartMoble smartMoble02 = (SmartMoble)moble02;
		smartMoble02.printfInfo();
	}
}

10.内部类
  定义在一个类里面的类。
  格式：

class Out
{
<span style="white-space:pre">	</span>class Inner()
<span style="white-space:pre">	</span>{
	
	}
}

在Out类中创建内部类对象  Inner in = new Inner();
在Out类外创建内部类对象  Out.Inner in = new Out().new Inner();


11.匿名内部类
  匿名内部类没有名字，所以在定义的时候就开始使用，并且只能通过该类创建一次对象


  内部类使用原则：内部类都当前的外部内使用。 

package com;

//外部类
//在Android中会大量的使用内部类
public class Student {

	String name;
	int score;
	BirthDay birthday;

	// 使用接口制作匿名内部类并且创建对象
	Inter01 inter = new Inter01() {

		public void fun01() {
			// TODO Auto-generated method stub
			System.out.println("fun01");
		}
	};

	public Student(int year, int month, int day) {
		// TODO Auto-generated constructor stub
		// 创建内部类对象
		birthday = new BirthDay(year, month, day);

		// 匿名内部类
		// 定义一个子类继承BirthDay，改写了printBirth方法。
		// 子类没有名字
		// 定义好子类后，立即使用子类创建对象
		BirthDay bd = new BirthDay() {
			@Override
			public void printBirth() {
				// TODO Auto-generated method stub
				System.out.println("my_birthday");
			}
		};

		bd.printBirth();

	}

	// 内部类
	interface Inter01 {
		public void fun01();
	}

	// 内部类：定义在类里面的。
	// 所有的访问控制修饰符都可以修饰内部类
	class BirthDay {

		int year;
		int month;
		int day;

		public BirthDay(int year, int month, int day) {
			// TODO Auto-generated constructor stub
			this.year = year;
			this.month = month;
			this.day = day;
		}

		public BirthDay() {
			// TODO Auto-generated constructor stub
		}

		public void printBirth() {
			System.out.println("birthday");
		}
	}
}
package com;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student s = new Student(1990, 4, 4);
		s.inter.fun01();
		
		//在外面创建内部类对象
		Student.BirthDay in = new Student(1990, 4, 4).new BirthDay();
	}
}

椰子哥·天行者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MDK_5.25版本
09-18
keil 5.25最新版本，百度云网盘下载，永久有效，版本亲测比较稳定
java封装printinfo_Java的封装
weixin_39862899的博客
02-27 703
1 封装封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。封装的步骤[1]属性私有化[2]提供公共的设置器和访问器[3]在设置器和访问器中添加业务校验逻辑public class Dog{// 【1】private 私有的，对外不可见private String name;private int health;private int lo...
JAVA快速入门-面向对象三大特性-继承性
itdo_just的博客
02-12 320
Tips: 继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。比如可以先定义一个类叫“车”，车有以下属性：车体大...
[零基础学JAVA]Java SE面向对象部分-17.面向对象高级（05）
weixin_33711641的博客
02-07 106
上季内容回顾： 1、对象的多态性 2、抽象类和接口 本季主要知识点： 抽象类和接口的实际应用 1、子类对象可以为父类对象实例化，之后调用的方法都是子类中已经被覆写过的方法。 2、就可以利用此特性，观察抽象类的使用，因为在抽象类中有很多的抽象方法。 抽象类 abstract class A    {            public abstract void fun()...
java中printlnInfo,在Java中system.out.println使用方法
weixin_29422145的博客
03-10 634
先输入sysout，然后输入辅助快捷键：Alt+/常用快捷键：1. ctrl+shift+r：打开资源这可能是所有快捷键组合中最省时间的了。这组快捷键可以打开工作区中任何一个文件，只需要按下文件名或mask名中的前几个字母，比如applic*.xml。美中不足的是这组快捷键并非在所有视图下都能用。2. ctrl+o：快速outline如果想要查看当前类的方法或某个特定方法，但又不想把代码拉上拉下，...
RouteOS 5.25
04-06
RouteOS 5.25 软路由系统软件，正版系统软件。 分享
ros5.25 img 完美破解版 L6
09-18
ros 5.25完美破解版 L6授权。版本稳定，无任何后门。
ROS5.25 ISO破解版
11-25
Ros5.25 ISO破解版, 解压出来刻盘可以直接用于启动安装。
LINQPad Premium 5.25.00
03-31
在5.25.00这个版本中，可能会包含一些bug修复、性能优化以及新的特性和改进。例如，可能增强了对最新.NET框架的支持，改进了代码编辑器的用户体验，或者增加了对新数据库驱动的兼容性。 文件名称"LINQPad Premium ...
print() java_java的print,printf,println以及输入
weixin_35219046的博客
02-12 513
java中有三种方式向控制台输入信息，分别是print，printf,println,现在简单介绍一下他们之间的异同。printf主要是继承了C语言的printf的一些特性，可以进行格式化输出print就是一般的标准输出，但是不换行println和print基本没什么差别，就是最后会换行看一下他们的效果：print：结果：从结果中可以明显看到，print输出内容之后，不会换行，光标定到最后一个字符...
方法覆写（重点）
编程语言基础知识
03-30 1897
现在已经清楚了继承的基本概念，那么此时就有可能出现这样的一种情况，如果子类限制定义了与父类相同的方法或者是属性的时候，这样的操作就称为覆写。1.方法覆写（重点）所谓的方法的覆写指的是子类定义了与父类方法名称、参数类型及个数完全相同的方法。但是被覆写的方法不能够拥有比父类更为严格的访问控制权限。范例：观察简单的方法覆写class Person{ public void printInfo() { ...
JAVA快速入门-面向对象三大特性-多态性
itdo_just的博客
02-12 301
Tips: 多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4 编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指...
匿名内部类
韩世雷 程序员专栏
08-19 616
interface A{ public void printInfo() ; // } class B implements A{ // 实现接口 public void printInfo(){ System.out.println("Hello World!!!")
Java基础突击第七天0013（匿名内部类，匿名对象，内部类）
u012144068的博客
07-07 207
public class TestJava{ } interface A{ public void printInfo(); } class B implements A{ public void printInfo(){ System.out.println("Hello"); } } class X{ public void fun1(){ this.fun2(...
java中关于==与equals方法不同及equals覆写
xu734816038的博客
11-17 698
首先，我们需要明确，==比较的是两个对象的地址，基本类型全部可用==比较（比较的是基本类型元素的值），可是除了基本类型之外的引用类型，如String，因不可比较地址，但其equals方法覆写了，所以可用作比较值。只有覆写了equals方法的才可以比较值，否则都是比较地址（由Object类中的equals得到）。 在关于集合的删除，查询中，一般需要覆写equals方法，因为如不覆写，则不知道通过什
java笔试题01
热门推荐
superervin的专栏
03-21 2万+
一． 选择题(共50题，每题2分，共100分。多选题选不全或选错都不得分。) 1． 以下属于面向对象的特征的是（C,D）。（两项） A) 重载 B) 重写 C) 封装 D) 继承 2． 以下代码运行输出是（C） public class Person{ private String name=”Person”; int age=0; } public class Chil
Java反射&JNI[Java Native Interface]（5.28）
安静的美男子
05-28 1279
1.反射   [1]通过反射机制，用户程序员可以知道任意类里面的所有属性和方法(哪怕是私有的)。对于任意对象，可以调用它的任意属性和方法。   [2].class文件加载后，JVM会生成一个类对象。类对象中包含：类中的所有构造，属性，行为。   [3]反射相关类         类对象包含：Constructor对象，Field对象，Method对象      Constructor对象
单例模式&异常处理（5.26）
安静的美男子
05-26 1062
1.数据类型   1.基本数据类型   2.引用数据类型 2.类，父类，子类，抽象类，内部类，匿名内部类，接口 3.类的结构   属性   行为   构造方法   语句块   内部类 4.类和类之间的关系   1.继承关系   2.包含关系 5.对象   实例化对象   new A();  1.申请内存  2.调用构造，初始化属性  
keil mdk 5.25
最新发布
11-05
Keil MDK 5.25是一款嵌入式开发环境软件集成套件。它是Keil公司的最新版本，用于开发和调试各种基于ARM Cortex-M处理器的嵌入式应用程序。 Keil MDK 5.25拥有一系列功能强大且易于使用的工具，包括编译器、调试器和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值