36.概念总结:
1.什么是多态性?什么是虚拟方法调用?
对象的多态性: 父类的引用执行子类的对象
Person p = new Nan();
p.ext()
调用方法时,编译看左边,运行看右边
2.一个类可以有几个直接父类,(只有一个)一个父类可以有多少个子类?(无数个)子类能获取直接父类的父类的结构吗?(可以)子类是否能获取父类中的private权限的属性或方法(可以getXX/setXXX)?
A is a B
3.方法的重写(override/overwrite)的具体规则有哪些?
形参列表相同
权限修饰符
返回值 : void -- void 基本数据类型 -- 基本数据类型
返回的异常
4.super调用构造器,有哪些具体的注意点
this(形参列表): 本类重载其他的构造器
super(形参列表): 调用父类中的执行构造器
必须写在首行(所以和this()不能同时存在)
------------------------------------------------------------------------------------------
1.什么是方法的重写(override 或 overwrite)？
子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作.
2. 应用：
重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
3.举例：
class Circle{
public double findArea(){}//求面积
}
class Cylinder extends Circle{
public double findArea(){}//求表面积
}
***************
class Account{
public boolean withdraw(double amt){}
}
class CheckAccount extends Account{
public boolean withdraw(double amt){}
}
4.重写的规则：
方法的声明： 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
* //方法体
* }
* 约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
* ① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
* ② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
* >特殊情况：子类不能重写父类中声明为private权限的方法
* ③ 返回值类型：
* >父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
* >父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
* >父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
* ④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
* **********************************************************************
* 子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写，要么都声明为static的（不是重写)。
5.面试题：
区分方法的重写和重载？
答：
① 二者的概念：
② 重载和重写的具体规则
③ 重载：不表现为多态性。
重写：表现为多态性。
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
而对于多态，只等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。
引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”
------------------------------------------------------------------------------------------
1.super 关键字可以理解为：父类的
2.可以用来调用的结构：
属性、方法、构造器
3.super调用属性、方法：
3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
3.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
4.super调用构造器：
4.1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！
4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二一，不能同时出现
4.4 在构造器的首行，没显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
4.5 在类的多个构造器中，至少一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器
------------------------------------------------------------------------------------------
理解即可。
1.从结果上看：继承性
> 子类继承父类以后，就获取了父类中声明的属性或方法。
> 创建子类的对象，在堆空间中，就会加载所父类中声明的属性。
2.从过程上看：
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，...直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所的父类的结构，所以才可以看到内存中父类中的结构，子类对象才可以考虑进行调用。
3.强调说明：
虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。
37.多态性总结:
1.多态性的理解：可以理解为一个事物的多种形态。
2.何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
举例：
Person p = new Man();
Object obj = new Date();
3.多态性的使用：虚拟方法调用
> 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
> 总结：编译，看左边；运行，看右边。
4.多态性的使用前提：
① 类的继承关系 ② 方法的重写
5.多态性的应用举例：
举例一：
public void func(Animal animal){//Animal animal = new Dog();
animal.eat();
animal.shout();
}
举例二：
public void method(Object obj){
}
举例三：
class Driver{
public void doData(Connection conn){//conn = new MySQlConnection(); / conn = new OracleConnection();
//规范的步骤去操作数据
// conn.method1();
// conn.method2();
// conn.method3();
}
}
6.多态性使用的注意点：
对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
************************************************************
7.关于向上转型与向下转型：
7.1 向上转型：多态
7.2 向下转型：
7.2.1 为什么使用向下转型：
有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特的属性和方法？使用向下转型。
7.2.2 如何实现向下转型：
使用强制类型转换符：()
7.2.3 使用时的注意点：
① 使用强转时，可能出现ClassCastException的异常。
② 为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
7.2.4 instanceof的使用：
① a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
② 如果 a instanceof A返回true,则 a instanceof B也返回true.其中，类B是类A的父类。
③ 要求a所属的类与类A必须是子类和父类的关系，否则编译错误。
7.2.5 图示：
8. 面试题：
8.1 谈谈你对多态性的理解？
① 实现代码的通用性。
② Object类中定义的public boolean equals(Object obj){ }
JDBC:使用java程序操作(获取数据库连接、CRUD)数据库(MySQL、Oracle、DB2、SQL Server)
③ 抽象类、接口的使用肯定体现了多态性。（抽象类、接口不能实例化）
8.2 多态是编译时行为还是运行时行为？
运行时的行为
38.java向下转型:
package com.atguigu.java;
import java.util.Date;
/*
* 面向对象特征之三：多态性
*
* 1.理解多态性：可以理解为一个事物的多种形态。
* 2.何为多态性：
* 对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
*
* 3. 多态的使用：虚拟方法调用
* 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
* 总结：编译，看左边；运行，看右边。
*
* 4.多态性的使用前提： ① 类的继承关系 ② 方法的重写
*
* 5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
*
* *************************************************************
*
*
*/
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.eat();
Man man = new Man();
man.eat();
man.age = 25;
man.earnMoney();
//*************************************************
System.out.println("*******************");
//对象的多态性：父类的引用指向子类的对象
Person p2 = new Man();
// Person p3 = new Woman();
//多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
p2.eat();
p2.walk();
// p2.earnMoney();
System.out.println(p2.id);//1001
System.out.println("****************************");
//不能调用子类所特有的方法、属性：编译时，p2是Person类型。
p2.name = "Tom";
// p2.earnMoney();
// p2.isSmoking = true;
//有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致
//编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
//如何才能调用子类特有的属性和方法？
//向下转型：使用强制类型转换符。
Man m1 = (Man)p2;
m1.earnMoney();
m1.isSmoking = true;
//使用强转时，可能出现ClassCastException的异常。
// Woman w1 = (Woman)p2; //类型不配的时候会报错
// w1.goShopping();
/*
* instanceof关键字的使用
*
* a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
*
*
* 使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先
* 进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
*
* 如果 a instanceof A返回true,则 a instanceof B也返回true.
* 其中，类B是类A的父类。
*/
if(p2 instanceof Woman){
Woman w1 = (Woman)p2;
w1.goShopping();
System.out.println("******Woman******");
}
if(p2 instanceof Man){
Man m2 = (Man)p2;
m2.earnMoney();
System.out.println("******Man******");
}
if(p2 instanceof Person){
System.out.println("******Person******");
}
if(p2 instanceof Object){
System.out.println("******Object******");
}
// if(p2 instanceof String){
//
// }
//练习：
//问题一：编译时通过，运行时不通过
//举例一：
// Person p3 = new Woman();
// Man m3 = (Man)p3;
//举例二：
// Person p4 = new Person();
// Man m4 = (Man)p4;
//问题二：编译通过，运行时也通过
// Object obj = new Woman();
// Person p = (Person)obj; //Women不是Person的父类
//问题三：编译不通过
// Man m5 = new Woman();
// String str = new Date();
// Object o = new Date();
// String str1 = (String)o;
}
}
//class Order{
//
//}
------------------------------------------------------
package com.atguigu.exer;
/*
* 练习：
* 1.若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，
* 系统将不可能把父类里的方法转移到子类中：编译看左边，运行看右边
*
* 2.对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，
* 这个实例变量依然不可能覆盖父类中定义的实例变量：编译运行都看左边
*/
class Base {
int count = 10;
public void display() {
System.out.println(this.count);
}
}
class Sub extends Base {
int count = 20;
public void display() {
System.out.println(this.count);
}
}
public class FieldMethodTest {
public static void main(String[] args) {
Sub s = new Sub();
System.out.println(s.count);//20
s.display();//20
Base b = s;//多态性
//==：对于引用数据类型来讲，比较的是两个引用数据类型变量的地址值是否相同
System.out.println(b == s);//true
System.out.println(b.count);//10
b.display();//20
}
}
38.多态练习1:
package com.atguigu.exer;
/*
* 建立InstanceTest 类，在类中定义方法method(Person e);
在method中:
(1)根据e的类型调用相应类的getInfo()方法。
(2)根据e的类型执行：
如果e为Person类的对象，输出：
“a person”;
如果e为Student类的对象，输出：
“a student”
“a person ”
如果e为Graduate类的对象，输出：
“a graduated student”
“a student”
“a person”
*/
public class InstanceTest {
public static void main(String[] args) {
InstanceTest test = new InstanceTest();
test.method(new Student());
}
public void method(Person e){
//虚拟方法调用
String info = e.getInfo();
System.out.println(info);
//方式一
// if(e instanceof Graduate){
// System.out.println("a graduated student");
// System.out.println("a student");
// System.out.println("a person");
// }else if(e instanceof Student){
// System.out.println("a student");
// System.out.println("a person");
// }else{
// System.out.println("a person");
// }
//方式二
if(e instanceof Graduate){
System.out.println("a graduated student");
}
if(e instanceof Student){
System.out.println("a student");
}
if(e instanceof Person){
System.out.println("a person");
}
}
}
class Person {
protected String name = "person";
protected int age = 50;
public String getInfo() {
return "Name: " + name + "\n" + "age: " + age;
}
}
class Student extends Person {
protected String school = "pku";
public String getInfo() {
return "Name: " + name + "\nage: " + age + "\nschool: " + school;
}
}
class Graduate extends Student {
public String major = "IT";
public String getInfo() {
return "Name: " + name + "\nage: " + age + "\nschool: " + school + "\nmajor:" + major;
}
}
40.equales和==
package com.atguigu.java1;
import java.util.Date;
/*
* 面试题： == 和 equals() 区别
*
* 一、回顾 == 的使用：
* == ：运算符
* 1. 可以使用在基本数据类型变量和引用数据类型变量中
* 2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
* 如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
* 补充： == 符号使用时，必须保证符号左右两边的变量类型一致。否则编译不通过
*
* 二、equals()方法的使用：
* 1. 是一个方法，而非运算符
* 2. 只能适用于引用数据类型
* 3. Object类中equals()的定义：
* public boolean equals(Object obj) {
return (this == obj);
}
* 说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
*
* 4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是
* 两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
*
* 5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们
* 就需要对Object类中的equals()进行重写.
* 重写的原则：比较两个对象的实体内容是否相同.
*/
public class EqualsTest {
public static void main(String[] args) {
//基本数据类型
int i = 10;
int j = 10;
double d = 10.0;
System.out.println(i == j);//true
System.out.println(i == d);//true
boolean b = true;
// System.out.println(i == b);
char c = 10;
System.out.println(i == c);//true
char c1 = 'A';
char c2 = 65;
System.out.println(c1 == c2);//true
//引用类型：
Customer cust1 = new Customer("Tom",21);
Customer cust2 = new Customer("Tom",21);
System.out.println(cust1 == cust2);//false
String str1 = new String("atguigu");
String str2 = new String("atguigu");
System.out.println(str1 == str2);//false
System.out.println("****************************");
System.out.println(cust1.equals(cust2));//false--->true
System.out.println(str1.equals(str2));//true
Date date1 = new Date(32432525324L);
Date date2 = new Date(32432525324L);
System.out.println(date1.equals(date2));//true
}
}
-------------------------------------------重写equales-------------------------------------------
package com.atguigu.java1;
public class Customer {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Customer() {
super();
}
public Customer(String name, int age) {
super();
this.name = name;
this.age = age;
}
//自动生成的equals()
// @Override
// public boolean equals(Object obj) {
// if (this == obj)
// return true;
// if (obj == null)
// return false;
// if (getClass() != obj.getClass())
// return false;
// Customer other = (Customer) obj;
// if (age != other.age)
// return false;
// if (name == null) {
// if (other.name != null)
// return false;
// } else if (!name.equals(other.name))
// return false;
// return true;
// }
//重写的原则：比较两个对象的实体内容(即：name和age)是否相同
//手动实现equals()的重写
// @Override
// public boolean equals(Object obj) {
//
//// System.out.println("Customer equals()....");
// if (this == obj) {
// return true;
// }
//
// if(obj instanceof Customer){
// Customer cust = (Customer)obj;
// //比较两个对象的每个属性是否都相同
//// if(this.age == cust.age && this.name.equals(cust.name)){
//// return true;
//// }else{
//// return false;
//// }
// //或
// return this.age == cust.age && this.name.equals(cust.name);
// }else{
// return false;
// }
//
// }
}
---------------------------------------练习题---------------------------------------
package com.atguigu.exer2;
/*
* 编写Order类，有int型的orderId，String型的orderName，
* 相应的getter()和setter()方法，两个参数的构造器，
* 重写父类的equals()方法：public boolean equals(Object obj)，
* 并判断测试类中创建的两个对象是否相等。
*/
public class OrderTest {
public static void main(String[] args) {
Order order1 = new Order(1001, "AA");
Order order2 = new Order(1001, "BB"); //true
Order order2 = new Order(1001, new String("BB"));
System.out.println(order1.equals(order2));
Order order3 = new Order(1001, "BB");
System.out.println(order2.equals(order3));
// String s1 = "BB";
// String s2 = "BB";
// System.out.println(s1 == s2);//true
}
}
class Order{
private int orderId;
private String orderName;
public int getOrderId() {
return orderId;
}
public void setOrderId(int orderId) {
this.orderId = orderId;
}
public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}
public Order(int orderId, String orderName) {
super();
this.orderId = orderId;
this.orderName = orderName;
}
@Override
public boolean equals(Object obj) {
if(this == obj){
return true;
}
if(obj instanceof Order){
Order order = (Order)obj;
//正确的：
return this.orderId == order.orderId &&
this.orderName.equals(order.orderName); //这里必须使用equales
//错误的：
// return this.orderId == order.orderId &&
// this.orderName == order.orderName;
}
return false;
}
}
41.toString方法
package com.atguigu.java1;
import java.util.Date;
/*
* Object类中toString()的使用：
* 1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
* 2. Object类中toString()的定义：
* public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
* 3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。
* 使得在调用对象的toString()时，返回"实体内容"信息
* 4. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"
*/
public class ToStringTest {
public static void main(String[] args) {
Customer cust1 = new Customer("Tom",21);
System.out.println(cust1.toString());//com.atguigu.java1.Customer@15db9742-->Customer[name = Tom,age = 21]
System.out.println(cust1);//com.atguigu.java1.Customer@15db9742-->Customer[name = Tom,age = 21]
String str = new String("MM");
System.out.println(str);//MM
Date date = new Date(4534534534543L);
System.out.println(date.toString());//Mon Sep 11 08:55:34 GMT+08:00 2113
}
}
-----------------------------------------重写toString--------------------------------------------
//手动实现
// @Override
// public String toString() {
// return "Customer[name = " + name + ",age = " + age + "]";
// }
//自动实现
@Override
public String toString() {
return "Customer [name=" + name + ", age=" + age + "]";
}
-------------------------------------------------------------------------------------------
package com.atguigu.exer3;
/*
* 写一个测试类，创建两个Circle对象，判断其颜色是否相等；
* 利用equals方法判断其半径是否相等；利用toString()方法输出其半径。
*/
public class CircleTest {
public static void main(String[] args) {
Circle circle1 = new Circle(2.3);
Circle circle2 = new Circle(3.3, new String("white"), 2.0);
System.out.println("颜色是否相等：" + circle1.getColor().equals(circle2.getColor()));
System.out.println("半径是否相等：" + circle1.equals(circle2));
System.out.println(circle1);
System.out.println(circle2.toString());
}
}
42.java单元测试:
package com.atguigu.java2;
import java.util.Date;
import org.junit.Test;
/*
* Java中的JUnit单元测试
* 步骤：
* 1.选中当前工程 - 右键选择：build path - add libraries - JUnit 4 - 下一步
* 2.创建Java类，进行单元测试。
* 此时的Java类要求：① 此类是public的 ②此类提供公共的无参的构造器（不需要写构造器或者构造器不能有参数）
* 3.此类中声明单元测试方法。
* 此时的单元测试方法：方法的权限是public,没有返回值，没有形参
* 4.此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：import org.junit.Test;
* 5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。
* 6.写完代码以后，左键双击单元测试方法名，右键：run as - JUnit Test
* 说明：
* 1.如果执行结果没有任何异常：绿条
* 2.如果执行结果出现异常：红条
*/
public class JUnitTest {
int num = 10;
@Test
public void testEquals(){
String s1 = "MM";
String s2 = "MM";
System.out.println(s1.equals(s2));
//ClassCastException的异常
// Object obj = new String("GG");
// Date date = (Date)obj;
System.out.println(num);
show();
}
public void show(){
num = 20;
System.out.println("show()....");
}
@Test
public void testToString(){
String s2 = "MM";
System.out.println(s2.toString());
}
}
43.java包装类:
package com.atguigu.java2;
import org.junit.Test;
/*
* 包装类的使用:
* 1.java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
* 2.掌握的：基本数据类型、包装类、String三者之间的相互转换
*/
public class WrapperTest {
//String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s)
@Test
public void test5(){
String str1 = "123";
//错误的情况：
// int num1 = (int)str1;
// Integer in1 = (Integer)str1;
//可能会报NumberFormatException
int num2 = Integer.parseInt(str1);
System.out.println(num2 + 1);
String str2 = "true1";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);
}
//基本数据类型、包装类--->String类型：调用String重载的valueOf(Xxx xxx)
@Test
public void test4(){
int num1 = 10;
//方式1：连接运算
String str1 = num1 + "";
//方式2：调用String的valueOf(Xxx xxx)
float f1 = 12.3f;
String str2 = String.valueOf(f1);//"12.3"
Double d1 = new Double(12.4);
String str3 = String.valueOf(d1);
System.out.println(str2);
System.out.println(str3);//"12.4"
}
/*
* JDK 5.0 新特性：自动装箱 与自动拆箱
*/
@Test
public void test3(){
int num1 = 10;
// //基本数据类型-->包装类的对象
method(num1);
//自动装箱：基本数据类型 --->包装类
int num2 = 10;
Integer in1 = num2;//自动装箱
boolean b1 = true;
Boolean b2 = b1;//自动装箱
//自动拆箱：包装类--->基本数据类型
System.out.println(in1.toString());
int num3 = in1;//自动拆箱
}
public void method(Object obj){
System.out.println(obj.toString());
}
//包装类--->基本数据类型:调用包装类Xxx的xxxValue()
@Test
public void test2(){
Integer in1 = new Integer(12);
int i1 = in1.intValue();
System.out.println(i1 + 1);
Float f1 = new Float(12.3);
float f2 = f1.floatValue();
System.out.println(f2 + 1);
}
//基本数据类型 --->包装类：调用包装类的构造器
@Test
public void test1(){
int num1 = 10;
// System.out.println(num1.toString());
Integer in1 = new Integer(num1);
System.out.println(in1.toString());
Integer in2 = new Integer("123");
System.out.println(in2.toString());
//报异常
// Integer in3 = new Integer("123abc");
// System.out.println(in3.toString());
Float f1 = new Float(12.3f);
Float f2 = new Float("12.3");
System.out.println(f1);
System.out.println(f2);
Boolean b1 = new Boolean(true);
Boolean b2 = new Boolean("TrUe");
System.out.println(b2);
Boolean b3 = new Boolean("true123");
System.out.println(b3);//false
Order order = new Order();
System.out.println(order.isMale);//false
System.out.println(order.isFemale);//null 它已经是一个引用数据类型
}
}
class Order{
boolean isMale;
Boolean isFemale;
}
-------------------------------------------面试题1------------------------------------
package com.atguigu.java2;
import org.junit.Test;
/*
* 关于包装类使用的面试题
*/
public class InterviewTest {
@Test
public void test1() {
//编译时候后面两只类型自动提升
Object o1 = true ? new Integer(1) : new Double(2.0);
System.out.println(o1);// 1.0
}
@Test
public void test2() {
Object o2;
if (true)
o2 = new Integer(1);
else
o2 = new Double(2.0);
System.out.println(o2);// 1
}
@Test
public void test3() {
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j);//false
//Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],
//保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在
//-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率
Integer m = 1;
Integer n = 1;
System.out.println(m == n);//true
Integer x = 128;//相当于new了一个Integer对象
Integer y = 128;//相当于new了一个Integer对象
System.out.println(x == y);//false
}
}
---------------------------------------------面试题2-------------------------------------
package com.atguigu.exer4;
import java.util.Scanner;
import java.util.Vector;
import org.omg.CORBA.VersionSpecHelper;
/*
* 利用Vector代替数组处理：从键盘读入学生成绩（以负数代表输入结束），找出最高分，并输出学生成绩等级。
提示：数组一旦创建，长度就固定不变，所以在创建数组前就需要知道它的长度。
而向量类java.util.Vector可以根据需要动态伸缩。
创建Vector对象：Vector v=new Vector();
给向量添加元素：v.addElement(Object obj); //obj必须是对象
取出向量中的元素：Object obj=v.elementAt(0);
注意第一个元素的下标是0，返回值是Object类型的。
计算向量的长度：v.size();
若与最高分相差10分内：A等；20分内：B等；
30分内：C等；其它：D等
*/
public class ScoreTest {
public static void main(String[] args) {
//1.实例化Scanner，用于从键盘获取学生成绩
Scanner scan = new Scanner(System.in);
//2.创建Vector对象：Vector v=new Vector();相当于原来的数组
Vector v = new Vector();
//3.通过for(;;)或while(true)方式，给Vector中添加数组
int maxScore = 0;
for(;;){
System.out.println("请输入学生成绩（以负数代表输入结束）");
int score = scan.nextInt();
//3.2 当输入是负数时，跳出循环
if(score < 0){
break;
}
if(score > 100){
System.out.println("输入的数据非法，请重新输入");
continue;
}
//3.1 添加操作：：v.addElement(Object obj)
//jdk5.0之前：
// Integer inScore = new Integer(score);
// v.addElement(inScore);//多态
//jdk5.0之后：
v.addElement(score);//自动装箱
//4.获取学生成绩的最大值
if(maxScore < score){
maxScore = score;
}
}
//5.遍历Vector，得到每个学生的成绩，并与最大成绩比较，得到每个学生的等级。
char level;
for(int i = 0;i < v.size();i++){
Object obj = v.elementAt(i);
//jdk 5.0之前：
// Integer inScore = (Integer)obj;
// int score = inScore.intValue();
//jdk 5.0之后：
int score = (int)obj;
if(maxScore - score <= 10){
level = 'A';
}else if(maxScore - score <= 20){
level = 'B';
}else if(maxScore - score <= 30){
level = 'C';
}else{
level = 'D';
}
System.out.println("student-" + i + " score is " + score + ",level is " + level);
}
}
}
44.object类说明:
1.java.lang.Object类的说明：
* 1.Object类是所Java类的根父类
* 2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
* 3.Object类中的功能(属性、方法)就具通用性。
* 属性：无
* 方法：equals() / toString() / getClass() /hashCode() / clone() / finalize()
* wait() 、 notify()、notifyAll()
*
* 4. Object类只声明了一个空参的构造器
2.equals()方法
2.1 equals()的使用：
1. 是一个方法，而非运算符
* 2. 只能适用于引用数据类型
* 3. Object类中equals()的定义：
* public boolean equals(Object obj) {
return (this == obj);
}
* 说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
*
* 4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是
* 两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
*
* 5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们
* 就需要对Object类中的equals()进行重写.
* 重写的原则：比较两个对象的实体内容是否相同.
2.2 如何重写equals()
2.2.1 手动重写举例：
class User{
String name;
int age;
//重写其equals()方法
public boolean equals(Object obj){
if(obj == this){
return true;
}
if(obj instanceof User){
User u = (User)obj;
return this.age == u.age && this.name.equals(u.name);
}
return false;
}
}
2.2.2 开发中如何实现：自动生成的
2.3 回顾 == 运算符的使用：
* == ：运算符
* 1. 可以使用在基本数据类型变量和引用数据类型变量中
* 2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
* 如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
* 补充： == 符号使用时，必须保证符号左右两边的变量类型一致。
3. toString()方法
3.1 toString()的使用：
1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
*
* 2. Object类中toString()的定义：
* public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
*
* 3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。
* 使得在调用对象的toString()时，返回"实体内容"信息
*
* 4. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"
3.2 如何重写toString()
举例：
//自动实现
@Override
public String toString() {
return "Customer [name=" + name + ", age=" + age + "]";
}
4.面试题：
① final、finally、finalize的区别？
② == 和 equals() 区别
45.单元测试方法说明:
* Java中的JUnit单元测试
*
* 步骤：
* 1.中当前工程 - 右键择：build path - add libraries - JUnit 4 - 下一步
* 2.创建Java类，进行单元测试。
* 此时的Java类要求：① 此类是public的 ②此类提供公共的无参的构造器
* 3.此类中声明单元测试方法。
* 此时的单元测试方法：方法的权限是public,没返回值，没形参
*
* 4.此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：import org.junit.Test;
*
* 5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。
* 6.写完代码以后，左键双击单元测试方法名，右键：run as - JUnit Test
*
* 说明：
* 1.如果执行结果没任何异常：绿条
* 2.如果执行结果出现异常：红条
46.包装类说明:
1.为什么要有包装类(或封装类）
为了使基本数据类型的变量具有类的特征，引入包装类。
2.基本数据类型与对应的包装类：
上图1
3.需要掌握的类型间的转换：（基本数据类型、包装类、String）
上图2
简易版：
基本数据类型<--->包装类：JDK 5.0 新特性：自动装箱 与自动拆箱
基本数据类型、包装类--->String:调用String重载的valueOf(Xxx xxx)
String--->基本数据类型、包装类:调用包装类的parseXxx(String s)
注意：转换时，可能会报NumberFormatException
应用场景举例：
① Vector类中关于添加元素，只定义了形参为Object类型的方法：
v.addElement(Object obj); //基本数据类型 --->包装类 --->使用多态
47.static关键字
package com.atguigu.java1;
/*
* static关键字的使用
*
* 1.static:静态的
* 2.static可以用来修饰：属性、方法、代码块、内部类
*
* 3.使用static修饰属性：静态变量（或类变量）
* 3.1 属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)
* 实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的
* 非静态属性时，不会导致其他对象中同样的属性值的修改。
* 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致
* 其他对象调用此静态变量时，是修改过了的。
* 3.2 static修饰属性的其他说明：
* ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
* ② 静态变量的加载要早于对象的创建。
* ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
*
* ④ 类变量 实例变量
* 类 yes no
* 对象 yes yes
*
* 3.3 静态属性举例：System.out; Math.PI;
*
* 4.使用static修饰方法：静态方法
* ① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
* ② 静态方法 非静态方法
* 类 yes no
* 对象 yes yes
* ③ 静态方法中，只能调用静态的方法或属性
* 非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
*
* 5. static注意点：(由于静态方法随类加载,比实例变量和方法加载的早,所以不能再其中调用实例的属性和方法)
* 5.1 在静态的方法内，不能使用this关键字、super关键字
* 5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。
*
* 6. 开发中，如何确定一个属性是否要声明为static的？
* > 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
* > 类中的常量也常常声明为static
*
* 开发中，如何确定一个方法是否要声明为static的？
* > 操作静态属性的方法，通常设置为static的
* > 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections
*/
public class StaticTest {
public static void main(String[] args) {
Chinese.nation = "中国";
Chinese c1 = new Chinese();
c1.name = "姚明";
c1.age = 40;
c1.nation = "CHN";
Chinese c2 = new Chinese();
c2.name = "马龙";
c2.age = 30;
c2.nation = "CHINA";
System.out.println(c1.nation);
//编译不通过
// Chinese.name = "张继科";
c1.eat();
Chinese.show();
//编译不通过
// Chinese.eat();
// Chinese.info();
}
}
//中国人
class Chinese{
String name;
int age;
static String nation;
public void eat(){
System.out.println("中国人吃中餐");
//调用非静态结构
this.info();
System.out.println("name :" +name);
//调用静态结构
walk();
System.out.println("nation : " + nation);
}
public static void show(){
System.out.println("我是一个中国人！");
//不能调用非静态的结构
// eat();
// name = "Tom";
//可以调用静态的结构
System.out.println(Chinese.nation);
walk();
}
public void info(){
System.out.println("name :" + name +",age : " + age);
}
public static void walk(){
}
}
---------------------------------------练习1-------------------------------------
48.单例设计模式:
package com.atguigu.java2;
/*
* 单例设计模式：
* 1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
* 2. 如何实现？
* 饿汉式 vs 懒汉式
* 3. 区分饿汉式 和 懒汉式
* 饿汉式：
* 坏处：对象加载时间过长。
* 好处：饿汉式是线程安全的
* 懒汉式：好处：延迟对象的创建。
* 目前的写法坏处：线程不安全。--->到多线程内容时，再修改
*/
public class SingletonTest1 {
public static void main(String[] args) {
// Bank bank1 = new Bank();
// Bank bank2 = new Bank();
Bank bank1 = Bank.getInstance();
Bank bank2 = Bank.getInstance();
System.out.println(bank1 == bank2);
}
}
//饿汉式
class Bank{
//1.私有化类的构造器
private Bank(){
}
//2.内部创建类的对象
//4.要求此对象也必须声明为静态的
private static Bank instance = new Bank();
//3.提供公共的静态的方法，返回类的对象
public static Bank getInstance(){
return instance;
}
}
----------------------------------------------方式二--------------------------------------------
package com.atguigu.java2;
/*
* 单例模式的懒汉式实现
*/
public class SingletonTest2 {
public static void main(String[] args) {
Order order1 = Order.getInstance();
Order order2 = Order.getInstance();
System.out.println(order1 == order2);
}
}
class Order{
//1.私有化类的构造器
private Order(){
}
//2.声明当前类对象，没有初始化
//4.此对象也必须声明为static的
private static Order instance = null;
//3.声明public、static的返回当前类对象的方法
public static Order getInstance(){
if(instance == null){
instance = new Order();
}
return instance;
}
}
49.java代码块:
package com.atguigu.java3;
/*
* 类的成员之四：代码块（或初始化块）
*
* 1. 代码块的作用：用来初始化类、对象
* 2. 代码块如果有修饰的话，只能使用static.
* 3. 分类：静态代码块 vs 非静态代码块
*
* 4. 静态代码块
* >内部可以有输出语句
* >随着类的加载而执行,而且只执行一次
* >作用：初始化类的信息
* >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
* >静态代码块的执行要优先于非静态代码块的执行
* >静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
*
* 5. 非静态代码块
* >内部可以有输出语句
* >随着对象的创建而执行
* >每创建一个对象，就执行一次非静态代码块
* >作用：可以在创建对象时，对对象的属性等进行初始化
* >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
* >非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
*
* 对属性可以赋值的位置:
* 1.默认初始化
* 2.显示初始化
* 3.构造器中初始化
* 4.有了对象之后,可以通过"对象.属性"或者"对象.方法"的方式,进行赋值
* 5.在代码块中赋值(先与构造器中的初始化执行)
*/
public class BlockTest {
public static void main(String[] args) {
String desc = Person.desc;
System.out.println(desc);
Person p1 = new Person();
Person p2 = new Person();
System.out.println(p1.age);
Person.info();
}
}
class Person{
//属性
String name;
int age;
static String desc = "我是一个人";
//构造器
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//非static的代码块
{
System.out.println("hello, block - 2");
}
{
System.out.println("hello, block - 1");
//调用非静态结构
age = 1;
eat();
//调用静态结构
desc = "我是一个爱学习的人1";
info();
}
//static的代码块
static{
System.out.println("hello,static block-2");
}
static{
System.out.println("hello,static block-1");
//调用静态结构
desc = "我是一个爱学习的人";
info();
//不可以调用非静态结构
// eat();
// name = "Tom";
}
//方法
public void eat(){
System.out.println("吃饭");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public static void info(){
System.out.println("我是一个快乐的人！");
}
}
---------------------------------------------练习1-------------------------------------------
package com.atguigu.java3;
//总结：由父及子，静态先行
class Root{
static{
System.out.println("Root的静态初始化块");
}
{
System.out.println("Root的普通初始化块"); //在调用构造方法时调用
}
public Root(){
super();
System.out.println("Root的无参数的构造器");
}
}
class Mid extends Root{
static{
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid(){
super();
System.out.println("Mid的无参数的构造器");
}
public Mid(String msg){
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值："
+ msg);
}
}
class Leaf extends Mid{
static{
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf(){
//通过super调用父类中有一个字符串参数的构造器
super("尚硅谷");
System.out.println("Leaf的构造器");
}
}
public class LeafTest{
public static void main(String[] args){
new Leaf();
System.out.println();
new Leaf();
}
}
----------------------------------------------练习2---------------------------------------
package com.atguigu.java3;
/*
* 对属性可以赋值的位置：
* ①默认初始化
* ②显式初始化/⑤在代码块中赋值(谁在前面就先执行谁)
* ③构造器中初始化
* ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
* 执行的先后顺序：① - ② / ⑤ - ③ - ④
*/
public class OrderTest {
public static void main(String[] args) {
Order order = new Order();
System.out.println(order.orderId);
}
}
class Order{
int orderId = 3;
{
orderId = 4;
}
}
50.final关键字:
package com.atguigu.java3;
/*
* final:最终的
*
* 1. final可以用来修饰的结构：类、方法、变量
*
* 2. final 用来修饰一个类:此类不能被其他类所继承。
* 比如：String类、System类、StringBuffer类
*
* 3. final 用来修饰方法：表明此方法不可以被重写
* 比如：Object类中getClass();
*
* 4. final 用来修饰变量：此时的"变量"就称为是一个常量
* 4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
* 4.2 final修饰局部变量：
* 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值
* 以后，就只能在方法体内使用此形参，但不能进行重新赋值。
*
* static final 用来修饰属性：全局常量
*/
public class FinalTest {
final int WIDTH = 0;
final int LEFT;
final int RIGHT;
// final int DOWN;
{
LEFT = 1;
}
public FinalTest(){
RIGHT = 2;
}
public FinalTest(int n){
RIGHT = n;
}
// public void setDown(int down){
// this.DOWN = down;
// }
public void doWidth(){
// width = 20;
}
public void show(){
final int NUM = 10;//常量
// NUM += 20;
}
public void show(final int num){
// num = 20;//编译不通过
System.out.println(num);
}
public static void main(String[] args) {
int num = 10;
num = num + 5;
FinalTest test = new FinalTest();
// test.setDown(3);
test.show(10);
}
}
final class FinalA{
}
//class B extends FinalA{
//
//}
//class C extends String{
//
//}
class AA{
public final void show(){
}
}
class BB extends AA{
// public void show(){
//
// }
}
-------------------------------------面试题--------------------------------------
1. static 修饰的属性，相较于实例变量，有哪些特别之处(>=3点)
随着类的加载而加载；早于对象的创建；只要权限允许，可以通过”对象.static属性”的方式进行调用；存在于方法区的静态域
2. final 可以用来修饰哪些结构，分别表示什么意思
3. 代码实现单例模式的饿汉式
4. 代码实现单例模式的懒汉式 -目前还是线程不安全的。
5. 类的属性赋值的位置有哪些？先后顺序为何？
默认初始化
显式初始化 、代码块中初始化
构造器中初始化
通过”对象.属性” 或”对象.方法”的方式赋值
