Java六-七章总结

最新推荐文章于 2022-08-03 11:33:08 发布

救赎~

最新推荐文章于 2022-08-03 11:33:08 发布

阅读量185

点赞数

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_62148534/article/details/124794585

版权

Java 专栏收录该内容

22 篇文章 1 订阅

订阅专栏

1-1 介绍类与对象
类（class）和对象(object)是两种以计算机为载体的计算机语言的合称。对象是对客观事物的抽象，类是对对象的抽象。类是一种抽象的数据类型。

1.类与对象的定义

类是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。

对象是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。

2.类与对象的关系

类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

3.类与对象的关系

4.Java创建类的语法

pubilc class 类名{
    //类的内容
}

1.类名要有直白意义，最好是英文。

2.首字母大写

3.不要数字开头，不要有特殊字符。

1-2 创建类与对象
1.创建类

在使用Java语言创建对象之前，首先要创建对象所属的类。Java语言使用关键字声明一个类。

声明一个类的完整语法是：

public class 类名{
 
//成员变量定义
 
//成员方法定义
 
}

其中“public”关键字是一种访问修饰级别，代表该类无论放在哪里都可以公开访问。

类是创建对象的模板，对象的属性在类中被定义为成员变量，对象的方法则被定义为成员方法。

行为定义：

方法为 public int length()

修饰符：

返回值的类型(void 表示无返回值)方法名(参数类型参数名){

语句部分

}
2.创建对象

类型创建完毕后，就该创建该类型的对象了。Java语言中，使用关键字“new”创建一个类型的对象。

“引用”中保存的对象地址可以通过以下几种方式获取

1.new关键字返回

2.通过其他引用变量赋值得到

3.通过方法返回得到

对象创建完毕后，可以使用“.”操作符访问对象的成员，包括设置或取得成员变量的值。

public class Dog {
    public static void main(String[] args) {
        Dog duoduo =new Dog(); 
        Dog lucky = new Dog();
}

1-3 成员变量
由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。

不同的对象的实例变量将被分配不同的内存空间，如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量，也就是说对象共享类变量。

成员变量和类变量的区别：

1、两个变量的生命周期不同

成员变量随着对象的创建而存在，随着对象的回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

2、调用方式不同

成员变量只能被对象调用。

静态变量可以被对象调用，还可以被类名调用。

3、别名不同

成员变量也称为实例变量。

静态变量也称为类变量。

4、数据存储位置不同

成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

static 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。

特点：

1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

2、被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名:静态方式。

3、静态随着类的加载而加载。而且优先于对象存在。

public class Dog {
	    String name; int age;
	    float weight;
	        public static void main(String[] args){
	            Dog duoduo=new Dog();
	            duoduo.name="多多";
	            duoduo.age = 6;
	            duoduo.weight =13.5f;
	            Dog lucky=new Dog();
	            lucky.name = "Lucky";
	            lucky.age =3;
	            lucky.weight =10.2f;
	            System.out.println(duoduo.name + "今天" + duoduo.age +"岁了");
	            System.out.println(lucky.name + "体重" + duoduo.weight +"千克");
	}
}

1-4 方法的作用
Method类

Method类是最终类，不能继承。

是用于完成特定功能的整段代码。

public class MethodSample01{
    public String isOddNumber(int num){
        System.out.println("原始数据为："+num);
        if(num%2==0){
            return "偶数";
        }else{
            return "奇数";
        }
    }
    public static void main(String[] args) {
       /* int a=10;
        if(a%2==0){
            System.out.println(a+"是偶数 ");
        }else {
            System.out.println(a+"是奇数");
        }
        int b=5;
        if(b%2==0){
            System.out.println(b+"是偶数");
        }else{
            System.out.println(b+"是奇数");
        }*/
        //在mian使用方法，先创建对象才能使用
        int a=10;
        MethodSample01 methodSample01=new MethodSample01();
        String r1=methodSample01.isOddNumber(a);
        System.out.println(a+"是"+r1);
        int b=5;
        String r2=methodSample01.isOddNumber(b);
        System.out.println(b+"是"+r2);
    }
}

第2章面向对象特性之封装
2-1 包-Package
Java 中使用 package 语句定义包，package 语句应该放在源文件的第一行，在每个源文件中只能有一个包定义语句，并且 package 语句适用于所有类型（类、接口、枚举和注释）的文件。定义包语法格式如下：

package 包名;

Java 包的命名规则如下：

1.包名全部由小写字母（多个单词也全部小写）。

2.如果包名包含多个层次，每个层次用“.”分割。

3.包名一般由倒置的域名开头，比如 com.baidu，不要有 www。

4.自定义包不能 java 开头。

注意：如果在源文件中没有定义包，那么类、接口、枚举和注释类型文件将会被放进一个无名的包中，也称为默认包。在实际企业开发中，通常不会把类定义在默认包下。

package com.micheal.test
public class Test {
}

java解释器会将package中的.解释为目录分隔符/，也就是说该文件的目录结构为：...com/micheal/test/Test.java
那么package中的类的访问权限是怎么样的呢？在同一package中的类是可以互相访问的，比如：

//Test1.java 
package test;
class Test1 {} 
//Test2.java
package test;
public class Test2 {
      public static void main(String[] args) {
            Test1 t;
      }
}

由于Test2与Test1在同一个package—test中，所以Test2能够直接调用Test1生成Test1的引用变量t；在命令行进行编译时，直接编译Test2.java即可：javac Test2.java（若没有进入Test1和Test2的目录，需在Test2前加上绝对路径）
若类在不同的package中，那么在一个类中要调用另一个package中的类（必须是public类，非public类不支持不同包间访问），需要在类名前明确加上package名称；不过，java中存在一个让java程序员偷懒的特性，叫做import关键字。使用import就可以在一个package中导入另一个package中的类，不过import和C语言和C++中的#include是不同的，import并不会在当前java文件中嵌入另一个package中的类的代码，只是告诉java文件，不属于该包的类能够到哪里去寻找而已：

package p1;
//import p2.Test2
 
public class Test1 {
      public static void main(String[] args) {         
          p2.Test2 t;//Test2 t if we import p2.Test2 before;
      }
}

2-2 访问修饰量
修饰类，变量，方法时：

public公共，任何地方都能使用；

private私有，只能在类中使用；

不加修饰词=default，包内其他类可以用；

protected继承，只能继承的子类可以使用；

访问修饰符：public protected default private
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
public：对所有类可见。使用对象：类、接口、变量、方法
protected：对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private：在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）
外部如何访问内部的私有成员变量适用本类中的共有方访问本类中的私有成员变量。

public class PackageSample01 {
    //public代表其他任何类都能访问成员变量
    public String name;
    //private代表只能在当前类中使用
    private void sayHello(){
        System.out.println("Hello World");
    }
    //不写修饰符代表是默认修饰符，只能被包中其他类访问
    void sayGoodbye(){
        System.out.println("Good bye!");
    }
    public static void main(String[] args) {
    	PackageSample01 packageSample01 = new PackageSample01();
    	packageSample01.sayHello();
    }
}

2-3 面向对象特性之封装
封装（Encapsulation）面向对象三大特性之一。封装的概念是将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。封装的好处是只能通过规定的方法访问数据，隐藏类的实例细节，方便修改和实现。

封装的概念是将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

封装的好处是只能通过规定的方法访问数据，隐藏类的实例细节，方便修改和实现。当我们使用一个类时只关注这个类能解决什么问题，并不关注这个类是如何实现的。

封装：

1.封装即隐藏功能的实现细节；

2.良好的封装代码更容易阅读和维护；

3.利用对象与方法是实现封装的直接途径。

2-4 对成员变量进行续写封装
对成员变量进行读写封装，是为了不允许用户修改某一些成员变量

对只允许读，不允许写的变量，只生成get方法，不生成set方法

public class MobileNumber {
    private String owner;
    private String areaCode;
    private String mobileNumber;
    //getter方法，用于读取成员变量的内容
    //getter书写格式，public 成员变量类型 get 成员变量名(),PS:首字母大写
    public String getOwner() {
        //this关键字代表当前对象的...
        return this.owner;
    }
    public String getAreaCode() {
        //this关键字代表当前对象的...
        return this.areaCode;
    }
    //setter方法，setter方法用于设置成员变量的内容
//setter书写格式：public void set成员变量名(新的数据参数)
    public void setOwner(String owner) {
        this.owner = owner;
    }
    public void setAreaCode(String areaCode) {
        this.areaCode = areaCode;
    }
}
 
public class MobileNumberTestor {
        public static void main(String[] args) {
            MobileNumber mobileNumber=new MobileNumber();
            mobileNumber.setOwner("老奇");
            String owner= mobileNumber.getOwner();
            System.out.println(owner);
            String areaCode=mobileNumber.getAreaCode();
            System.out.println(areaCode);
    }
}

第3章面向对象特性之继承和多态
3-1 面向对象之继承
继承（英语：inheritance）是面向对象软件技术当中的一个概念。如果一个类别A“继承自”另一个类别B，就把这个A称为“B的子类别”，而把B称为“A的父类别”也可以称“B是A的超类”。继承可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能。另外，为子类别追加新的属性和方法也是常见的做法。一般静态的面向对象编程语言，继承属于静态的，意即在子类别的行为在编译期就已经决定，无法在执行期扩充。

优点 1.功能复用：将已有的属性和行为继承过来，实现功能的复用，节省了大量工作。
2.便于扩展功能：在已有功能的基础上，更容易建立、扩展新功能。
3.结构清晰，简化认识：同属于一个继承体系的相关类，他们之间结构层次清晰，简化了人们对代码结构的认识。
4.易维护性：不同类之间的继承关系，让事物之间保持一致性，大大降低了维护成本。
缺点
打破了封装性：父类向子类暴露了实现细节，打破了父类对象的封装性。
高耦合性：类与类之间紧密结合在一起，相互依赖性高。

public class Mark1 {
   protected String title;
   protected String color;
   protected String movie;
   public void description(){
       System.out.println("型号:"+title);
       System.out.println("颜色:"+color);
       System.out.println("首次出现电影:"+movie);
   }
  
 private void fire(){
       System.out.println("利用手臂燃料泵射出火焰");
   }
   public static void main(String[] args) {
       Mark1 mark1=new Mark1();
       mark1.color="银灰色";
       mark1.movie="钢铁侠1";
       mark1.title="马克1型";
       mark1.description();
       mark1.fire();
   }
}

public class Hulk extends Mark1{
    public static void main (String[] args) {
        Hulk hulk = new Hulk();
        hulk.title ="反浩克装甲";
        hulk.color = "红色";
        hulk.movie = "复仇者联盟3";
        hulk.description();
    }  
}

3-2 面向对象特性之多态

public class Mark85 extends Mark1{
    private void createShield() {
        System.out.println("利用纳米技术生成防御护盾");
    }
    public static void main(String[] args) {
        Mark85 mark85 = new Mark85();
        mark85.title ="马克85型";
        mark85.color ="红色";
        mark85.movie ="复仇者联盟4";
        mark85.description();
        mark85.createShield();
    }
}

多态的存在要有3个必要条件

(多态是指方法的多态，属性没有多态)要有继承；

要有方法重写；

父类引用指向子类对象。

多态的前提

1）要有继承或实现关系

2）要有方法的重写

3）要有父类引用指向子类对象

引用变量的两种类型：

编译时类型（模糊一点，一般是一个父类）由声明时的类型决定。

运行时类型（运行时，具体是哪个子类就是哪个子类）由实际对应的对象类型决定。

优点：提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

缺点：不能使用子类的特有成员

多态：同一个行为具有多个不同的表现形式或形态的能力，根据输入的内容不同，去产生不同的接口实现

实现多态的关键是接口

接口：是一个抽象的类型，只提供方法的定义

实现类：是一个借口的具体实现，要实现每一个接口方法的功能

一个接口可以拥有多个实现类

interface Language {
	public void voice();
}
public class Chinese implements Language{
	@Override
	public void voice() {
		System.out.println("你好,有什么可以帮到你的?");
	}
}
public class English implements Language{
	@Override
	public void voice() {
		System.out.println("Hi,may I help you?");
	}  
}
public class French implements Language{
@Override
public void voice() {
	System.out.println("Comment puis-je me rendre a l'h pital");
	}
}
public class CustomerService {
	public static void main(String[] args) {
		Language language = new English();
		language.voice();
		Language languagel = new Chinese();
		languagel.voice();
		Language language2 = new French();
		language2.voice();
	}
}

3-3 ArrayList列表类的使用
ArrayList类是List接口的实现，允许我们创建可调整大小的数组。

1.向列表添加数据

对象名.add();

对象名.add(索引位置,数据)// 像当前数组尾部添加数据

2、泛型：<>

List <数据类型> 对象名 = new ArrayList<数据类型>();

3、得到指定位置数据

对象名.get(索引位置);

4、获得列表的数值总数

对象名.size();

5、移除数据

对象名.remove(索引位置);

6、移除最后一项数据

对象名.remove(对象名.size()-1);

7、遍历列表所有数据

For( 数据类型 变量名 ：列表名){
 
//循环体
 
}

import java.util.ArrayList;
import java.util.List;
public class ArrayListSample {
   public static void main(String[] args) {
     //泛型<类型>,用于规范列表中的数据
       List<String> bookList=new ArrayList<String>();//创建ArrayList对象
       bookList.add("红楼梦");//向列表末端追加数据
       bookList.add("西游记");
       bookList.add("水浒传");
       bookList.add("三国志");
       bookList.add("index:0，element“镜花缘");
       System.out.println(bookList);
       String bookName=bookList.get(2);//得到指定索引位置（从0开始）
       System.out.println(bookName);
       int size=bookList.size();//得到列表总数
       System.out.println(size);
       bookList.remove(2);
       bookList.remove(bookList.size()-1);
       System.out.println(bookList);
       for (String book:bookList){
           System.out.println("《"+book+"》");
       }
   }
}

救赎~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java六-七章总结

1-1 介绍类与对象类（class）和对象(object)是两种以计算机为载体的计算机语言的合称。对象是对客观事物的抽象，类是对对象的抽象。类是一种抽象的数据类型。1.类与对象的定义类是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。对象是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。2.类与对象的关系类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储...
复制链接

扫一扫