##面向对象
1—面向对象是一种思想.相对面向过程而言的,相对简单.
2–,万物皆对象
3–,面向对象的特征:
–封装性,把相关的数据封装成一个“类”组件
–继承性,是子类自动共享父类属性和方法,这是类之间的一种关系
–多态,增强软件的灵活性和重用性
类和对象的创建和使用
//测试 类和对象
//一个.java文件中,可以包含多个类.只不过,只能有一个类,被public修饰.
//而且,被public修饰的类名就是.java文件名.
public class Test6_Class {
public static void main(String[] args) {
//根据汽车类这个模板,创建一个汽车对象来干活
//使用new关键字,创建对象
// new Car();//匿名对象
Car c = new Car();//对象的名字叫BMW
//使用模板里的方法
c.run();
c.back();
//设置c对象的信息
c.price = 10.9 ;
c.peizhi = '高' ;
c.color = "black";
c.model = "X6";
//使用模板里的属性/变量
System.out.println( c.price );//0.0
System.out.println( c.peizhi );//\u0000
System.out.println( c.color );//null
System.out.println( c.model );//null
}
}
//使用class关键字创建汽车类 ,用来描述汽车事物
class Car{
//描述事物的特征 -- 成员属性/实例变量/成员变量(在类里方法外)
//型号,颜色,价格,配置
double price ;//小数类型的默认值是0.0
String color ;//引用类型的默认值是null
String model ;
char peizhi ;//char类型的默认值是\u0000
//描述事物的功能 -- 成员方法/成员函数
//前进 后退
public void run() {
System.out.println("run()...");
}
public void back() {
System.out.println("back()...");
}
}
--2,分析手机事物:
-- 属性:颜色,尺寸,品牌,价格。。。
-- 行为:打电话,发短信,听音乐。。。。
-- 测试:
//练习手机类
public class Test1_Class {
public static void main(String[] args) {
//TODO 创建手机对象测试
//new Phone().call();//匿名对象--只干一件事情
Phone p = new Phone() ;
//调用模板里的方法
p.call();
p.music();
p.message();
//设置p对象的具体信息
p.color = "red" ;
p.size = 5.7 ;
p.pinpai = "HUAWEI" ;
p.price = 5999.9 ;
//调用模板里的属性
System.out.println( p.color );//null
System.out.println( p.size );//0.0
System.out.println( p.pinpai );//null
System.out.println( p.price );//0.0
}
}
–3,创建多个对象测试
//练习手机类
public class Test1_Class {
public static void main(String[] args) {
//创建手机对象测试
new Phone().call();//匿名对象--只干一件事情
new Phone().music();//匿名对象--只干一件事情
Phone p = new Phone() ;
//调用模板里的方法
p.call();
p.music();
p.message();
//设置p对象的具体信息
p.color = "red" ;
p.size = 5.7 ;
p.pinpai = "HUAWEI" ;
p.price = 5999.9 ;
//调用模板里的属性
System.out.println( p.color );
System.out.println( p.size );
System.out.println( p.pinpai );
System.out.println( p.price );
//TODO 创建p2 p3对象测试
Phone p2 = new Phone() ;
//调用模板里的方法
p2.call();
p2.music();
p2.message();
//设置p对象的具体信息
p2.color = "white" ;
p2.size = 6.3 ;
p2.pinpai = "VIVO" ;
p2.price = 3999.9 ;
//调用模板里的属性
System.out.println( p2.color );
System.out.println( p2.size );
System.out.println( p2.pinpai );
System.out.println( p2.price );
Phone p3 = p2 ;
System.out.println( p3.color );
System.out.println( p3.size );
System.out.println( p3.pinpai );
System.out.println( p3.price );
}
}
##封装
–1,通过private关键字实现封装,来提高程序的安全性.可以封装成员变量,也可以封装成员方法.被private修饰后,只能在本类中可见.
–2,练习1:封装学生类
//测试封装
public class Test2_Private {
public static void main(String[] args) {
// 创建Student对象测试
Student s = new Student();
s.coding();
//s.chiji();//2,因为chiji()已经被封装了,外界无法使用!!
//设置属性的值
// s.name="jack";//4,因为name已经被封装了,外界无法使用!!
// s.age=20 ;
s.setName("jack");
s.setAge(20);
//获取属性的值
// System.out.println( s.name );//4,因为name已经被封装了,外界无法使用!!
// System.out.println( s.age );//0
System.out.println( s.getName() );//jack
System.out.println( s.getAge() );
// System.out.println( s.score );//0.0
}
}
// 提供Student类
class Student{
//特征
private String name ;
//5,当属性被private后,外界就没法直接获取或者设置了!!--提供公共的访问方式
//提供公共的设置方式 setXxx()
public void setName(String n){
//拿到你提供的n的值,给name属性赋值
name = n ;
}
//提供公共的获取方式 getXxx()
public String getName(){
return name;//把name属性的值,返回给外界的调用位置
}
//TODO 封装
private int age ;
public void setAge(int a) {
age = a;
}
public int getAge(){
return age ;
}
//自动-右键-source-generate getters and setters-select all-ok
private double score ;
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
//TODO 封装
private String addr ;
private long id ;
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
//行为
public void coding() {
//3, 在类里, 提供间接的访问方式
chiji();
System.out.println("coding()...");
}
//1,通过private关键字,实现封装.只能在本类中访问
private void chiji() {
System.out.println("chiji()...");
}
}
构造方法
–1,用来创建对象 或者 完成对象的初始化.
–2,构造方法可以重载(方法名相同,参数列表不同)
–语法: 修饰符 类名([参数列表]) { 方法体 }
–3,练习1:构造方法创建对象
//测试 构造方法
//总结
//1, 构造方法的语法: 修饰符 类名(参数列表){}
//2, 构造方法的触发时间节点: 创建对象/new/实例化
//3, 构造方法可以重载,目的是为了,方便外界比较灵活的创建对象
public class Test3_Constructor {
public static void main(String[] args) {
//1,创建Teacher对象
Teacher t = new Teacher();//触发无参构造方法
//4,创建Teacher对象 -- 触发含参构造方法
Teacher t2 = new Teacher("李铁蛋");//触发String类型的含参构造
Teacher t3 = new Teacher(39);//触发int类型的含参构造
Teacher t4 = new Teacher("李铁蛋",39);//触发String和int的含参构造
}
}
//提供Teacher类
//构造方法语法: 修饰符 类名([参数列表]){ 方法体 }
class Teacher{
//2, 无参构造方法 默认就存在 ---前提是:不要只提供含参构造,否则就真没了!!
public Teacher() {
System.out.println(123);
}
//3, 含参构造方法 的重载 -- 方法名相同但是参数列表不同!!
public Teacher(String name) {
System.out.println("老师叫:"+name);
}
//重载的构造方法
public Teacher(int age) {
System.out.println("老师"+age+"岁.");
}
//TODO 重载的构造方法
public Teacher(String name,int age){
System.out.println("老师叫:"+name+",今年:"+age+"岁.");
}
}
--4,练习2:构造方法赋值
//测试 构造方法
//总结
//1, 构造方法的语法: 修饰符 类名(参数列表){}
//2, 构造方法的触发时间节点: 创建对象/new/实例化
//3, 构造方法可以重载,目的是为了,方便外界比较灵活的创建对象
public class Test3_Constructor {
public static void main(String[] args) {
//1,创建Teacher对象
Teacher t = new Teacher();//触发无参构造方法
//4,创建Teacher对象 -- 触发含参构造方法
Teacher t2 = new Teacher("王二狗");//触发String类型的含参构造
Teacher t3 = new Teacher(39);//触发int类型的含参构造
Teacher t4 = new Teacher("王二狗",39);//触发String和int的含参构造
}
}
//提供Teacher类
//构造方法语法: 修饰符 类名([参数列表]){ 方法体 }
class Teacher{
String name ;
//2, 无参构造方法 默认就存在 ---前提是:不要只提供含参构造,否则就真没了!!
public Teacher() {
System.out.println(123);
}
//3, 含参构造方法 的重载 -- 方法名相同但是参数列表不同!!
public Teacher(String n) {
name = n ; // ----------!!!构造方法还可以给成员变量赋值!!!---------
System.out.println("老师叫:"+n);
}
//重载的构造方法
public Teacher(int age) {
System.out.println("老师"+age+"岁.");
}
//重载的构造方法
public Teacher(String name,int age){
System.out.println("老师叫:"+name+",今年:"+age+"岁.");
}
}