|
1面向对象
作者： 1521456746@qq.com
|
1封装性：将对象的属性和行为封装起来，不需要让外界知道具体细节。
2继承性：描述类与类之间的关系，通过继承，可以无需重新编写原有类的情况下，对原有类的功能进行拓展。增强了代码的复用性，提高开发效率，为程序的修补提供了便利。
3.多态性：程序中允许出现重名现象，他指在一个类中定义的属性和方法被其他类继承后，他们可以具有不同的数据类型或表现出不同行为，使得同一个属性和方法在不同类中具有不同的语义。
|
1面向对象①
|
类与对象
类的定义：面向对象最核心是的就是就是对象，要创建对象要先创建一个类，类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，又称作属性。成员方法用于描述对象的行为，简称方法。
//定义一个类
class lei {
String name;
int age ;
public void introduce(){
System. out.println("大家好，我叫:" +name +"，今年" +age +"岁。" );
}
}
public class s3{
public static void main(String[]args){
lei s2= new lei(); //为lei类创建一个对象s2
s2. name="杰克" ; //为对象赋值
s2. age=-70; //为对象赋值
s2.introduce(); //调用lei类内的introduce方法
s2= null; //为s2属性赋值为null，切断属性对象的关系
s2.introduce(); //再次调用对象的方法，此时s1与对象的关系被切断，失去对象
}
}
输出结果：
大家好，我叫:杰克，今年-70岁。
Exception in thread "main" java.lang.NullPointerException
at s3.main( s3.java:16)
★：
1.null是一种特殊的常量，当一个变量的值为null时，则表示变量不指向任何一个对象。
|
1面向对象②
|
类的封装：
封装的定义：指在定义一个类时，将类中的属性私有化，，即用private关键字来修饰，私有属性只能在它所在类中被访问。
//定义一个类
class Student {
private String name ; //将name属性私有化
private int age ; //将age属性私有化
//定义公有的方法getXxx()和setXxx()
public String getName(){ //用于获取name属性的值
return name ;
}
public void setName(String stuName){//用于设置name的值
name=stuName;
}
public int gatAge(){ //用于获取age的值
return age ;
}
public void setAge(int stuAge){ //用于设置age的值
if(stuAge<=0&&stuAge>150){ //设置年龄输入范围
System. out.println("你输入的年龄不合法......" );
}
else{
age=stuAge;
}
}
//定义一个方法
public void introduce(){
System. out.println("大家好，我的名叫:" +name +",我今年" +age +"岁！" );
}
}
public class s4{
public static void main(String[]args){
Student stu= new Student(); //创建Student方法的对象
stu.setAge(-30); //为setAge属性赋值，最后会被传到age属性
stu.setName( "李芳"); //为setName属性赋值，最后会被传到name属性
stu.introduce(); //调用introduce方法
}
}
输出结果：
年龄不合法......
大家好，我的名叫:李芳,我今年0岁！
★：
1.age属性类型是int，默认值为0，若传入的值不符合范围，会打印“你输入的年龄不合法......”的信息，age没有被赋值，仍为初始值0.
2.为了能让外界访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的getXxx（）方法和设置属性值的SetXxx（）方法。
|
1面向对象③
|
构造方法：
1.一个类中定义的方法能同时满足一下三个条件，就能算作构造方法：
①方法名与类名相同
②在方法名前没有返回值类型的声明。
③在方法中不能使用return语句返回一个值。
2.构造方法分为有参构造方法和无参构造方法， 有参与无参的区别就是有参构造能够在new的时候同时给创建的对象中的数据赋值。
3.一个类被实例化时，这个类的构造方法会被自动调用 “new 类名(空或参数)”语句的作用除了会实话对象外，还会调用他的构造方法。
3.构造方法的重载：一个；类中可以定义多个构造方法，只要每个构造方法的参数类型或参数个数不同即可。在创建对象时，可以通过调用不同的构造方法为不同的属性赋值。
例子：
//定义一个类
class per {
String name;
int age;
//定义有参的构造方法1
public per(int a){
System.out.println( "有参的构造方法1被调用" );
age=a;
}
//定义有参的构造方法2
public per(String n,int a){
System.out.println( "有参的构造方法2被调用" );
age=a;
name=n;
}
public per(){
System.out.println( "无参的构造方法被调用" );
}
public void speak(){
System.out.println( "我叫:"+name+"，今年" +age+"岁！");
}
public void speak1(){
System.out.println( "我今年" +age+"岁！");
}
public void stt(String p){
}
}
class haha{
String caa;
public haha(){
System.out.println( "无参的构造方法被调用" );
}
public void aaa(String c){
caa=c;
System.out.println( "笑：“"+caa+"。”" );
System.out.println(c);
}
}
public class s5 {
public static void main(String[]args){
per s= new per(18); //实例化per对象并调用有参构造方法
per ss= new per("小明" ,20); //实例化per对象并调用有参构造方法
haha p= new haha(); //实例化haha对象并调用无参构造方法
s.speak(); //per类的s对象调用spea()方法
ss.speak1(); //per类的s对象调用spea1()方法
p.aaa( "哈哈哈"); //haha类的p对象调用aaa()
}
}
输出结果：
有参的构造方法1被调用
有参的构造方法2被调用
无参的构造方法被调用
我今年18岁！
我叫:小明，今年20岁！
笑：“哈哈哈。”
哈哈哈
★：
1.Java的每一个类都至少有一个构造方法，如果在一个类中没有定义构造方法，系统会自动为这个类创建一个默认的没有任何代码的无参的构造方法，即什么也不做的构造方法，但为该类定义任何的构造方法后，系统将不再提供默认的构造方法了。
|
1面向对象④
|
this关键字：
作用： 解决命名冲突，调用同一个类的其他构造方法
在JAVA中，为了程序可读性，有时会需要将一个类中多个表示同样含义的变量（如表示年龄）进行统一的命名，但这样会导致成员变量和局部变量的名称冲突，在方法中将无法访问成员变量，为解决这个问题，java中提供了一个关键字this，用于在方法中访问对象的其他成员。
可以调用：成员变量
成员方法
其他构造方法 this.([参数1]，[参数2])
例子：
//定义一个类
class saon{+
String name="小明" ; //定义局部变量
public saon(String n){ //定义有参的构造方法
System. out.println("我本来叫" +name );
this.name =n; //定义一个与局部变量同名的成员变量
System. out.println("有参的构造方法被调用" );
this.caa(); //调用无参构造方法
}
public saon(){
this("王二狗" ); //调用有参的构造方法
System. out.println("现在改名叫" +name );
}
public void caa(){ //定义无参的构造方法
System. out.println("无参的构造方法被调用" );
}
}
public class s8 {
public static void main(String[] mags){
saon p=new saon(); //实例化saon的对象
}
}
输出结果：
我本来叫小明
有参的构造方法被调用
无参的构造方法被调用
现在改名叫王二狗
★：使用this调用类的构造方法时，要注意以下几点：
1.只能在构造方法中使用this调用其他构造方法，不能在成员方法中使用。
2.在构造方法中，使用this调用构造方法的语句必须位于第一位，且只能出现一次。
3.不能在一个类的两个构造方法中使用this相互调用。那若是三个或更多的构造方法呢？
|
1面向对象⑤
|
垃圾回收
在java中当一个对象成为垃圾后仍会占用内存空间，时间长数量多厚就会导致内存不足，所以Java引入了垃圾回收机制，当垃圾堆积到一定程度时，自动回收垃圾。也可以通过调用Systm.gc()方法来命令虚拟机马上进行垃圾回收。
例子：
class person1 {
public void finalize(){
System. out.println("对象将会作为垃圾回收。。。。。。" );
}
}
public class s9 {
public static void main(String[] args){
person1 p1=new person1();
person1 p2=new person1();
p1= null;
p2= null;
System. gc(); //垃圾回收指令
for(int i=0;i<10000000;i++){
//为了更好看到垃圾对象回收过程，延长程序时间
}
}
}
|
1面向对象⑥
|
static关键字
用于修饰类的成员，可以修饰成员变量，成员方法以及代码块等，被static修饰的成员具备一些特殊性。
1.静态代码块：实例共享
有时候我们希望某些特定的数据在内存中只存在一份，而且能够被一个类的所有实例所共享。用“类名.变量名”的形式访问。
例子：
class Sstudent {
static String zyName; //定义一个静态变量zyName
}
public class s10 {
public static void main(String[]args){
Sstudent stu1= new Sstudent(); //实例化Sstudent对象
Sstudent stu2= new Sstudent(); //实例化Sstudent对象
Sstudent. zyName="大学生" ; //为静态变量赋值
System. out.println("小明" +stu1.zyName); //调用静态变量，打印打一个对象
System. out.println("小红" +stu2.zyName); //调用静态变量，打印打二个对象
}
}
★：static只能修饰成员变量，不能修饰局部变量。
2.静态方法：
可以在不建对象的情况下就可以调用某个方法，使该方法不必和对象绑在一起，。用“ 类名.方法名”的形式访问。
例子：
//定义一个类
class peee{
public static void sayHello(){//定义静态方法
//定义一个类
class peee{
public static void sayHello(){//定义静态方法
System. out.println("hello" );
}
}
public class s11 {
public static void main(String[]args){
peee. sayHello();//类名.方法名，调用静态方法
}
}
输出结果：
hello
★：在一个静态方法在只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法被调用时可以不创建任何对象。
3.静态代码块：
Java类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用static修饰打代码块被称为静态代码块。当类被加载时，代码块就会被执行，由于类只加载一次，所以静态代码块也只执行一次。静态代码块通常被用于类的成员变量进行初始化。
例子：
//定义一个类
class peee{
static String country;
//下面是一个静态代码块
static{
country="china" ;
System. out.println("peee类中的静态代码块执行了" );
}
}
class s11{
static{
System. out.println("测试类的静态代码块执行了" );
}
public static void main(String[] args){
peee p1=new peee(); //第一次实例化peee对象，类被加载，静态代码块会被执行
peee p2=new peee(); //第二次实例化peee对象，类不会再被加载，静态代码块不会再被执行
}
}
输出结果：
测试类的静态代码块执行了
peee类中的静态代码块执行了
4.单例模式：
是一种设计模式，指在设计一个类时，需要保证整个运行期间针对该类只存在一个实例对象。
特点：
1.类的构造方法使用private修饰，声明为私有，这样也就不能在类的外部使用new关键字来创建实例对象了。
2.在类额内部创建一个该类的实例对象，并使用静态变量
例子：
//单例模式写法一
class single {
//自己创建一个对象
private static single INSTANCE= new single();
private single(){} //私有化构造方法
public static single getInstance(){ //提供返回该对象的静态方法
return INSTANCE ;
}
}
//单例模式写法二
//class single{
// private single(){} //构造方法私有化
// public static final single INSTANCE=new single();
//}
class s12{
public static void main(String[]args){
single s1=single. getInstance();
single s2=single. getInstance();
System. out.println(s1==s2);
}
}
输出：
turn
s1=s2,这说明两个变量引用同一对象，两次调用的getInstance()方法使同一对象，而getInstance()方法是获得single类实例的唯一途径，因此single是一个单例的类。
写法二中，首先将类的构造方法私有，防止外界创建该类的实例。在类的内部创建了该类的实例对向，并使用静态变量INSTANCE 来引用，INSTANCE 前的三个修饰符中，public的作用是允许外部直接访问该变量，static的作用是让外部可以使用‘类.命名’的方式来访问变量，final的作用是禁止外部对该变量进行修改，因此访问变量INSTANCE 是获得single类实例对象的唯一途径，所以实现单例。
浙公网安备 33010602011771号