文章目录
1.Object类:
equals() :
Object类是比较对象;String重写了;
class Student{//Object
private int no;
private String name;
public Student(int no, String name) {
this.no = no;
this.name = name;
}
//重写
@Override
public boolean equals(Object obj) {
// this , obj
// this <-> (Student)obj
Student stu = (Student)obj;
boolean result = (this.no == stu.no && this.name.equals(stu.name));
return result;
}
public String show() {
return no + "," + name;
}
@Override // guojing.equals(yangkang);
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
// Student guojing Teacher yangkang
if (this.getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (this.name == null) {
//yangkang
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (no != other.no)
return false;
return true;
}
}
public class TestObject {
public static void main(String[] args) {
Student guojing = new Student(11, "郭靖");
Student yangkang = new Student(11, "郭靖");
System.out.println(guojing.equals(yangkang));//true
}
}
finalize():清理资源。
垃圾回收器 在释放对象之前会调用。
//强制垃圾回收
System.gc();
Runtime.getRuntime().gc();
class Demo{
@Override
protected void finalize() throws Throwable {
System.out.println("this---->" + this);//地址
}
}
public class TestFinalize {
public static void main(String[] args) {
Demo demo = new Demo();
System.out.println(demo);//地址
demo = null;
//强制垃圾回收
System.gc();
Runtime.getRuntime().gc();
//上面两个一样的
System.out.println(demo);
}
toString():
使用print()或 println()输出对象名时,会隐式调用toString()的。、
class Employee{
private int no;
private String name;
public Employee(int no, String name) {
super();
this.no = no;
this.name = name;
}
@Override
public String toString() {
return no + "," + name;
}
}
public class TestToString {
public static void main(String[] args) {
Employee guojing = new Employee(11,"郭靖");
System.out.println(guojing);
}
}
2.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.封装:
隐藏细节;
1 private 容量
2 public 容量 get(){}
3 protected void set(){}
4 final
3.实现关系
组合:整体类和局部类的关系。
语法:局部类作为整体类的成员变量;
/**
* 局部
*/
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();
}
}
4.抽象类
抽象类:只定义了类的抽象行为,没有具体实现相应的行为。
注意:
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();
}
}
5.接口
接口:一组规则的封装。
5.1 语法
注意:
1)成员都是 public的;
2)常量 :public static final
3) 抽象方法:public abstract的
4)默认方法: public default
5.2 接口特点:
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");
}
}
示例四:
interface WebBank{
void webService(); //简单
public abstract void webService();//复杂,和上面一个意思
}
//实现类
class Jingdong implements WebBank{
@Override
public void webService() {
System.out.println("京东实现了网上支付");
}
}
class Taobao implements WebBank{
@Override
public void webService() {
System.out.println("淘宝提供了网上支付功能");
}
}
public class TestWebBank {
public static void main(String[] args) {
Jingdong jd = new Jingdong();
jd.webService();
Taobao taobao = new Taobao();
taobao.webService();
}
}
6.编写:利用组合 汽车的组成
class Engine{
public void start() {System.out.println("发动机启动");}
public void stop() {System.out.println("发动机停止");}
}
class Wheel{
public void inflate(int n) {
System.out.println("车轮充气:" + n);
}
}
class Window{
public void roolUp() {System.out.println("车窗升");}
public void roolDown() {System.out.println("车窗降");}
}
class Door{
Window win = new Window();
public void open() {System.out.println("车门开");}
public void close() {System.out.println("车门关");}
}
class Car{
Engine engine;
// Wheel w1 = new Wheel();
// Wheel w2 = new Wheel();
// Wheel w3 = new Wheel();
// Wheel w4 = new Wheel();
Wheel [] wheels;
Door[] doors;
{
engine = new Engine();
wheels = new Wheel[4];// null,null,null,null
for(int i = 0; i < wheels.length; i++) {
wheels[i] = new Wheel();
}
doors = new Door[2];
for(int i = 0; i < doors.length; i++) {
doors[i] = new Door();
}
}
}
public class TestCar_exam {
public static void main(String[] args) {
Car car = new Car();
for(int i = 0; i < car.wheels.length; i++) {
car.wheels[i].inflate(100);
}
car.doors[0].win.roolUp();
car.doors[1].win.roolDown();
car.doors[0].open();
car.doors[1].close();
car.engine.start();
car.engine.stop();
}
}
--------------------------------------
/1.5
class Engine{
public void start() {System.out.println("启动");}
public void stop() {System.out.println("停止");}
}
class Wheel{
public void inflate(int load)
{System.out.println("车轮充气"+load+"%");}
}
class Window{
public void roolUp() {System.out.println("车窗升");}
public void roolDown() {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 = new Engine();
Wheel wheel = new Wheel();
// Wheel wheel2 = new Wheel();
// Wheel wheel3 = new Wheel();
// Wheel wheel4 = new Wheel();
Door door = new Door();
// Door door2 = new Door();
}
public class Demo5 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Car car = new Car();
System.out.println("四个车轮:");
for (int i = 0; i < 4; i++) {
car.wheel.inflate(100);
}
car.door.open();
car.door.window.roolUp();
car.door.close();
car.door.window.roolDown();
car.engine.start();
}
}
7.编写:抽象类 职位的内容展示
abstract class Job{
private String jobType;
public Job(String jobType) {
this.jobType = jobType;
}
public String getJobType() {
return jobType;
}
public abstract void showJob();//抽象方法
}
class CodeJob extends Job{
private int codingLines;
private int bugs;
public CodeJob(String jobType,int codingLines,int bugs) {
super(jobType);//调用父类构造
this.codingLines = codingLines;
this.bugs = bugs;
}
@Override
public void showJob() {
System.out.println("我是一名"
+ getJobType()
+ ",每天的代码行数"
+ codingLines
+ ",错误数:"
+ bugs);
}
}
public class TestJob_exam {
public static void main(String[] args) {
CodeJob job = new CodeJob("软件开发工程师", 1000, 2);
job.showJob();
}
}
8.编写:接口 实现书信接口
interface Letter{
public abstract void writeHeader();
void writeBody();
void writeFooter();
}
class HomeLetter implements Letter{
@Override
public void writeHeader() {
System.out.println("亲爱的父母:");
}
@Override
public void writeBody() {
System.out.println("我在北京一切都好,每天都在努力的学习,同学们非常好,请放心!");
}
@Override
public void writeFooter() {
System.out.println("\t\t\t\t郭靖 2019-7-6");
}
}
public class TestLetter_exam {
public static void main(String[] args) {
HomeLetter letter = new HomeLetter();
letter.writeHeader();
letter.writeBody();
letter.writeFooter();
}
}
9.java的垃圾回收机制分析
java的垃圾回收机制篇幅过大,另起一篇专门介绍
10.Hashcode算法研究
实例:
public int hashCode() {
final int prime = 31;
int result = 1;
// 31 *
result = prime * result + no;
return result;
}
}
public class TestHashCode {
public static void main(String[] args) {
Book book = new Book(11, "计算机基础");
System.out.println(book.hashCode());
String str = "ab";// char [] value = {'a','b'};
System.out.println(str.hashCode());//hash编码结果3105
}
}
JDK 中, String 类型是如何重写 hashCode 方法的呢?
源码:
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
代码非常简单,就是使用 String 的 char 数组的数字每次乘以 31 再叠加最后返回,因此,每个不同的字符串,返回的 hashCode 肯定不一样。
那么为什么使用 31 呢?
在名著 《Effective Java》第 42 页就有对 hashCode 为什么采用 31 做了说明:
之所以使用 31, 是因为他是一个奇素数。
如果乘数是偶数,并且乘法溢出的话,信息就会丢失,因为与2相乘等价于移位运算(低位补0)。
31 有个很好的性能,即用移位和减法来代替乘法,可以得到更好的性能:
31 * i == (i << 5) - i,
现代的JVM 可以自动完成这种优化。
使用 31 最主要的还是为了性能。当然用 63 也可以。但是 63 的溢出风险就更大了。
11.注意:
1.黄色是protect修饰的
绿色的是private修饰的
2.强制垃圾回收,
System.gc(); Runtime.getRuntime().gc();
这两个是通知垃圾回收过来回收
3.课下看看java垃圾回收咋回事的
4.hascode算法
5.final主要是让被修饰的东西不可被修改
6.final修饰的对象不能修改,但对象的属性值可以修改
7.抽象父类定义的抽象方法,那么子类必须重写这个方法。
8.普通类之中不可以定义抽象方法;只有抽象类才可以定义抽象方法
9.抽象方法不能pricate,static,final一起使用
10.接口:不能创建对象;使用是通过实现类来使用的;实现类实现接口的功能,必须实现所有的抽象方法;抽象的实现类除外;实现类可以实现多个接口的功能;接口之间可以继承,可以多继承.。
11.在接口里void webServiece();
相当于
public abstract void webServiece();
12.在接口里使用implemwents关键字可以继承接口定义的功能
13.接口中的静态方法不能被子接口和实现类所继承