21 面向对象
//面向对象的概念是相对于面向过程而言的,所谓面向对象其实是从执行者变成了指挥者.面向对象中包含很多的类,是具有相同属性和行为的同一类事物.
//面向对象类的示例
class CarDemo01
{
public static void main(String[] args)
{
Car c = new Car();//建立一个car对象
c.color="black";//对属性进行修改
c.run();//调用方法
}
}
class Car
{
String color = "red";//给属性进行赋初值
int door = 1;
void run()//这是一个方法,用来被其他具体对象调用
{
//System.out.println("The car is
running...");
System.out.println(color+"...The car is
running...");
}
}
22 封装 :
-----private关键字:
|-----(1)是一个权限修饰符
|-----(2)用于修饰成员变量或者成员函数
|-----(3)被私有化的成员变量或函数只能在本类中才能被访问
-----功能:
|-----对外提供set 和get方法进行访问,这样提高了数据的安全性
23 构造函数:
---------特点:
|----函数名字与类名相同
|----不用定义返回值类型
|----不可以写return语句
---------作用:
|-----给对象进行初始化
---------注意事项:
|-----默认构造函数的特点
|-----多个构造函数是以重载的形式存在的
构造代码块:
--------给对象进行初始化,对象已建立就开始运行,而且优先于构造函数执行
和构造函数的区别:
---------构造代码块是给所有对象进行初始化,而构造函数是给调用的对象进行初始化
//构造函数示例
class Person
{
private String name;
private int age;
//构造代码块
{
System.out.println("\n你好,我来啦...........");
}
//构造函数,可以重载
Person()
{
print();
}
Person(String name)
{
this.name=name;
print();
}
Person(String name,int age)
{
this.name=name;
this.age=age;
print();
}
Punlic static void print()
{
System.out.println("姓名:"+name+",年龄:"+age);
}
}
class PersonDemo03
{
public static void main(String[] args)
{
Person p1 = new Person();
Person p2 = new Person("zhangsan");
Person p3 = new Person("lisi",20);
}
}
24 this 关键字:
--------特点是代表所在函数所属对象的引用,即this代表本类对象的引用
--------当在函数内需要永达调用该函数的对象时,就可以使用
this语句:
---------用于构造函数之间互相调用,只能定义在构造函数的第一句
示例:
class Person
{
private String name;
private int age;
Person(String name)
{
this.name=name;
}
Person(String name,int age)
{
this()name;//this语句,表示
this.name=name,
this.age=age;
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person();
p.setName("zhangsan");
p.setAge(20);
//p.run();
}
}
class Person
{
private String name;
private int age;
public void setName(String name)
{
this.name=name;
run();
}
public String getName()
{
return name;
}
public void setAge(int age)
{
this.age=age;
run();
}
public int getAge()
{
return age;
}
private void run()
{
System.out.print("姓名:"+name+",年
龄:"+age);
}
}
25 static: 静态
------用法:是一个修饰符,用于修饰成员变量和成员函数
被修饰后的成员具有一下特点:
----优先类的加载而加载
|---随着类的加载到方法区中的静态区中
----优于对象存在(静态先存在,对象后存在)
----被所有对象共享
----可以直接被类名调用
-----什么时候使用静态:
对象中共享数据可以使用static ,定义成静态
使用注意:
--------静态方法只能访问静态成员,非静态方法既可以访问静态也可以访问非静态
--------静态方法中不可以有this,super关键字(因为静态优先于对象存在)
--------主函数是静态的
实例变量和类变量区别:
------存放位置> 类变量随着类的加载而存在于方法区中
实例变量随着对象的建立而存在于对内存中
------生命周期> 类变量生命周期最长,随着类的消失而消失
实例变量生命周期随着对象的消失而消失
class Person
{
String name;//成员变量,实例变量
static String country="中国";//静态的成员变量,为对象所共享
public void show()
{
System.out.println(name+"....."+country);
}
}
class StaticDemo01
{
public static void main(String[] args)
{
System.out.println(Person.country);
}
}
26 单例设计模式: 解决一个类在内存只存在一个对象
想要保证对象唯一
-----为了避免其他程序过多建立该类对象,先禁止其他程序建立该类对象
-----为了让其他程序可以访问到该类对象,只好在本类中 自定义一个对象
-----为了让其他程序对自定义对象的访问,可以对外提供一些访问方式
思路步骤:
----将构造函数私有化
----在类中创建一个本类对象
----提供一个方法可以获取到该对象
//饿汉式单例模式(安全,开发常用模式)
public class Single
{
private Single()//将构造函数私有化
{}
private static final Single s = new Single();//创建本类对象并私有化,防止其他类修改
public static Single getInstance()//主函数没有对象,所以只有静态之后才可以访问
{
return s;
}
}
public class SingDemo
{
public static void main(String[] args)
{
//new Single();
//new Single();
Single ss=Single.getInstance();//静态方法调用
System.out.println(ss);
}
}
//懒汉式(延迟加载,不安全,面试常用)
class Single
{
private Single(){}
private static Single s=null;
public static Single getInstance()
{
if(s==null)
{
s=new Single();
}
return s;
}
}
public class SingDemo
{
public static void main(String[] args)
{
Single ss=Single.getInstance();
System.out.println(ss);
}
}
27 继承:
----子类继承父类之后会拥有父类中的成员,成员变量和成员函数(不是全部)
---继承使用的关键字是extends
---父类是子类共性内容提取出来的
---继承的好处是减少代码量,提供代码复用性
---继承的出现,使用类和类出现了关系,导致了面向对象第三个特征多态
---子类可以直接使用父类的成员(不是全部,私有的无法继承)
成员特点:
---成员变量
---super关键字,区分子类和父类重名的成员变量
---子类有就用子类的,子类没有就用父类的
---成员函数
---子类出现了和父类一模一样的函数,函数的覆盖特性
---覆盖保证子类中的权限大于或者等于父类中的权限
构造函数
---子类继承不了
---子类的构造函数默认第一行有super();
---子类的所有构造函数都会访问父类的构造函数
---子类的构造函数可以简介的访问父类中的构造函数
class Person
{
private String name;
private int age;
//获取姓名年龄
public String getName()
{
return this.name;
}
public int getAge()
{
return this.age;
}
}
class Student extends Person
{
public void study()
{
System.out.println("学生在学习java........."+getName()+"******"+getAge());
}
}
class Work extends Person
{
public void work()
{
System.out.println("工人在制造汽车---------"+getName()+"********"+getAge());
}
}
class ExtendsDemo01
{
public static void main(String[] args)
{
Student s=new Student();
s.study();
Work w = new Work();
w.work();
}
}
//函数继承和函数覆盖示例
class Phone
{
public void call()
{
System.out.println("通话......");
}
public void incoming()
{
System.out.println("来电显示.......");
}
}
class NewPhone extends Phone
{
public void incoming()复写父类方法
{
super.incoming();//继承父类方法
System.out.println("彩铃");
System.out.println("大头照...");
}
}
class Iphone extends Phone
{
public void incoming()
{
super.incoming();
System.out.println("视频电话.....");
System.out.println("Hello World!");
}
}
class OverrideDemo01
{
public static void main(String[] args)
{
Iphone p = new Iphone();
p.call();
p.incoming();
}
}
28 抽象类
---抽象类,是子类中共性的方法抽取的,但是父类中抽取的方法描述不清楚
---抽象方法,没有方法体,用abstract进行修饰,抽象方法存在于抽象类中
---类也要用abstract修饰
---抽象类中可以没有抽象方法
---抽象类不能实例化对象
---子类继承抽象类,覆盖抽象类中的全部抽象方法,建立子类的对象
---子类继承了抽象类,没有完全覆盖抽象方法,子类还是一个抽象类
---建立子类的对象,需要子类完全覆盖抽象方法
abstract class Company
{
//私有化变量,防止外部修改
private String name;
private int age;
private int number;
private double pay;
//初始化变量
Company(String name,int age,int number,double pay)
{
this.name = name;
this.age = age;
this.number = number;
this.pay = pay;
}
//提供供外部访问的方法
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public double getPay()
{
return pay;
}
abstract public void job();
}
//经理类继承公司类
class Manager extends Company
{
private double bouns;
//构造函数
Manager(String name,int age,int number,double pay,double bouns)
{
super(name,age,number,pay);//继承父类变量
this.bouns = bouns;
}
public void job()
{
System.out.println("姓名:"+getName()+"--年龄:"+getAge()+"--工资"+getPay()+"--奖金"+bouns);
}
}
class Programmer extends Company
{
Programmer(String name,int age,int number,double pay)
{
super(name,age,number,pay);
}
public void job()
{
System.out.println("姓名:"+getName()+"--年龄"+getAge()+"--工资"+getPay());
}
}
class ExtendsDemo01
{
public static void main(String[] args)
{
Manager m = new Manager("zhangsan",20,007,10000.0,15000.0);
m.job();
Programmer p = new Programmer("lisi",22,001,12000.0);
p.job();
}
}
747
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
