Java基础学习笔记：第四章（六）面向对象编程

最新推荐文章于 2020-10-06 11:20:11 发布
最新推荐文章于 2020-10-06 11:20:11 发布
阅读量180 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LastYHM/article/details/107265731
版权

知识点1：static关键字

static关键字的使用
 *
 * 1. static：静态的
 * 2. 可以用来修饰：属性、方法、内部类、代码块
 *
 * 3. 使用static修饰属性：
 *
 *   3.1 回顾变量按照在类中声明的位置来分：
 *      成员变量（属性）：
 *              类变量（或静态变量）
 *              实例变量（或非静态变量）
 *      局部变量：
 *              方法内、构造器内、代码块内定义的
 *              方法形参、构造器形参
 *   3.2 非静态属性的特点:
 *     每当我们创建一个类的实例，内存中就会在堆空间里分配一套类的非静态变量。类的多个实例的相同属性之间
 *     没有任何关系。
 *   3.3 静态属性的特点：
 *      ① 类的多个实例共享类的静态属性
 *      ② 类的静态属性在内存中就只有一份。存在于方法区的静态域中。
 *      ③ 类的静态属性随着类的加载而加载。
 *        （对比：类的非静态属性随着对象的创建而加载）
 *      ④          静态属性         非静态属性
 *      类           yes             no
 *      对象         yes             yes
 *      ⑤ 当通过一个对象修改静态属性时，会导致其它对象对此静态属性的调用。
 *
 * 4. 使用static修饰方法：
 *      ① 随着类的加载而加载
 *      ②          静态方法         非静态方法
 *        类         yes             no
 *       对象        yes             yes
 *      ③ 静态方法内只能调用静态的属性、静态的方法。不能调用非静态的结构：属性、方法
 *        非静态的方法内可以调用静态的结构或非静态的结构：属性、方法
 *
 *
 * 5. 什么情况下适合将属性声明为static的？
 *     ① 当一个类的多个对象关于某一属性的值都是相同时，可以声明为static的。即：没有必要
 *      给每个对象分配一份此属性的值时。
 *     ② 工具类中的属性通常都是静态的。
 *
 *    什么情况下适合将方法声明为static的？
 *     ① 通常操作静态属性的方法设置为静态的。（比如：get和set方法）
 *     ② 工具类中的方法通常都是静态方法
 *
  • 代码演示
public class StaticTest {
    public static void main(String[] args) {
        Chinese c1 = new Chinese();
        c1.name = "姚明";
        c1.age = 38;
        c1.nation = "CHN";

        Chinese c2 = new Chinese();
        c2.name = "刘翔";
        c2.age = 35;
        c2.nation = "中国";

        c1.info();
        c2.info();

        //使用"类.静态变量"的方式访问静态变量
        System.out.println(Chinese.nation); //Math.PI
        //不能使用"类.非静态变量"
//        System.out.println(Chinese.name);

        Chinese.show();//Math.sqrt(..),Math.random(),Math.round(..),Arrrys.sort(..)

    }
}

class Chinese{
    //非静态变量（或实例变量）
    String name;
     int age;
    //静态变量（或类变量）
     static String nation;

    public void info(){
        System.out.println("name = " + name + ", age = " + age + ", nation = " + nation);
        show();
    }

    public static void show(){
        System.out.println("我是中国人！！");
        System.out.println("nation = " + nation);
        //不能调用非静态的结构
//        System.out.println("name = " + name);
//        info();
    }

}
  • static的应用1
package com.atguigu.java1;

/**
 * static的应用举例
 * @author shkstart
 * @create 2020-07-08 11:16
 */
public class CircleTest {
    public static void main(String[] args) {
        Circle c1 = new Circle(1.2);
        System.out.println(c1);

        Circle c2 = new Circle(2.2);
        System.out.println(c2);

        Circle c3 = new Circle();
        System.out.println(c3);

        System.out.println("创建的圆的个数为：" + Circle.getCircleInstanceCount());
    }
}

class Circle{
    private double radius;//半径
    private int id;//编号

    private static int init = 1001;

    private static int circleInstanceCount;//记录创建的圆的个数

    public Circle(double radius){
//        this();
        this.radius = radius;
        this.id = init++;
        circleInstanceCount++;
    }

    public Circle(){
        this.id = init++;
        circleInstanceCount++;
    }

    @Override
    public String toString() {
        return "Circle{" +
                "radius=" + radius +
                ", id=" + id +
                '}';
    }

    public int getId() {
        return id;
    }

    public static int getCircleInstanceCount() {
        return circleInstanceCount;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }
}
  • static的应用2
package com.atguigu.exer;

/**
 * 编写一个类实现银行账户的概念，包含的属性有“帐号”、“密码”、“存款余额”、“利率”、
 * “最小余额”，定义封装这些属性的方法。账号要自动生成。
 * 编写主类，使用银行账户类，输入、输出3个储户的上述信息。
 * 考虑：哪些属性可以设计成static属性。
 * @author shkstart
 * @create 2020-07-08 15:09
 */
public class AccountTest {
    public static void main(String[] args) {
        Account acct1 = new Account();
        Account acct2 = new Account("qwerty",3000);
        Account acct3 = new Account("asdfg",2000);


        System.out.println(acct1);
        System.out.println(acct2);
        System.out.println(acct3);

    }
}

class Account{
    private int id ;//账号
    private String password = "000000";//密码
    private double balance;//存款余额

    private static double interestRate;//存款利率
    private static double minBalance;//最小余额

    private static int init = 1000;//用于自动生成账号的属性

    public Account(){
        this.id = ++init;
    }

    public Account(String password,double balance){
        this();
        //this.id = ++init;
        this.password = password;
        this.balance = balance;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public static double getInterestRate() {
        return interestRate;
    }

    public static void setInterestRate(double interestRate) {
        Account.interestRate = interestRate;
    }

    public static double getMinBalance() {
        return minBalance;
    }

    public static void setMinBalance(double minBalance) {
        Account.minBalance = minBalance;
    }

    public int getId() {
        return id;
    }

    public double getBalance() {
        return balance;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", password='" + password + '\'' +
                ", balance=" + balance +
                '}';
    }
}

知识点2：单例模式

  • 设计模式
 * 1.设计模式：是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模免去我们自己再思考和摸索。
 * 就像是经典的棋谱，不同的棋局，我们用不同的棋谱。    ”套路”
 *
 * 经典的设计模式有23种
 
创建型模式，共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 
结构型模式，共7种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 
行为型模式，共11种：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 

对软件设计模式的研究造就了一本可能是面向对象设计方面最有影响的书籍：《设计模式》：《Design Patterns: Elements of Reusable Object-Oriented Software》（即后述《设计模式》一书），由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 合著（Addison-Wesley，1995）。这几位作者常被称为"四人组（Gang of Four）"，而这本书也就被称为"四人组（或 GoF）"书。
  • 单例模式
  2. 单例模式（单子模式，singleton）：在整个的软件系统中，对某个类只能存在一个对象实例
 *
 * 3. 如何实现单例模式：
 *    饿汉式、懒汉式
 *
 *    对比？
 *    懒汉式好：延迟了对象的创建
 *      >有线程安全问题。
 *    饿汉式好：没有线程的安全问题。
  • 饿汉式
public class SingletonTest {
    public static void main(String[] args) {
//        Bank bank1 = new Bank();
//        Bank bank1 = new Bank();

        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();

        System.out.println(bank1 == bank2);
    }
}
//饿汉式
class Bank{

    //1. 私有化类的构造器
    private Bank(){

    }

    //2. 在类的内部创建对象
    private static Bank bank = new Bank();

    //3. 提供访问该对象的get方法
    public static Bank getInstance(){
        return bank;
    }
}
  • 懒汉式
/**
 * 单例模式之懒汉式
 *
 * @author shkstart
 * @create 2020-07-08 11:53
 */
public class SingletonTest1 {
    public static void main(String[] args) {
        Application app1 = Application.getInstance();
        Application app2 = Application.getInstance();

        System.out.println(app1 == app2);

    }
}

class Application{

    //1. 私有化类的构造器
    private Application(){}

    //2.声明当前类的实例
    private static Application app = null;

    //3. 调用方法时，根据app是否初始化，进行赋值。并返回
    public static Application getInstance(){
        if(app == null){
            app = new Application();
        }
        return app;

    }
}

知识点3：体会main()

/**
 * main()的理解
 * 1. 作为程序的入口
 * 2. 可以看做是一个普通的静态方法
 * 3. 除了使用Scanner之外，也可以使用main()从控制台传入需要的数据。都作为String
 *    类型的变量接收。
 * @author shkstart
 * @create 2020-07-08 14:08
 */
public class MainDemo {
    public static void main(String args[]) {
        Main.main(new String[10]);
    }
}

class Main{
    public static void main(String[] args) {
        for(int i = 0;i < args.length;i++){
            args[i] = "args_" + i;
            System.out.println(args[i]);
        }
    }
}
  • 如何在调用main()时，传参数

在这里插入图片描述

知识点4：代码块

 * 类的成员之四：代码块的使用
 *
 * 1. 从格式上讲，命名为：代码块
 *    从功能上讲，命名为：初始化块
 *
 * 2.代码块的分类：静态代码块 、 非静态代码块
 *
 * 3. 静态代码块：
 *      1. 内部可以编写执行语句
 *      2. 随着类的加载而执行
 *      3. 静态代码块的执行要早于非静态代码块
 *      4. 静态代码块只执行一次
 *      5. 如果类中定义了多个静态代码块，则按照声明的先后顺序执行
 *      6. 在内部可以调用当前类中的静态结构：属性、方法。不能调用非静态的结构
 *      7. 作用：用来初始化当前类的静态属性。
 *
 *
 * 4. 非静态代码块：
 *      1. 内部可以编写执行语句
 *      2. 随着对象的创建而执行
 *      3. 每创建一个对象，非静态代码块就执行一次
 *      4. 如果类中定义了多个非静态代码块，则按照声明的先后顺序执行
 *      5. 在内部可以调用当前类中的静态结构和非静态结构：属性、方法
 *      6. 作用：用来初始化创建的对象的实例变量。
  • 代码演示
public class BlockTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println();
        Person p2 = new Person();
        System.out.println();
        Person p3 = new Person();

    }
}

class Person{
    String name;
    int age;
    static String info = "我是人类";

    public void eat(){
        System.out.println("吃饭");
    }
    public static void show(){
        System.out.println("我是一个勤劳的人类");
    }

    public Person(){
//        System.out.println("Person()....");
    }

    //非静态代码块
    {
        System.out.println("我是非静态代码块1");
        //可以调用类中静态的结构
        System.out.println(info);
        show();
        //可以调用类中静态的结构
        System.out.println(name);
        eat();
    }
    {
        System.out.println("我是非静态代码块2");
    }


    //静态代码块
    static {
        System.out.println("我是静态代码块1");
        //可以调用类中静态的结构
        System.out.println(info);
        show();
        //不可以调用类中静态的结构
//        System.out.println(name);
//        eat();

    }
    static {
        System.out.println("我是静态代码块2");
    }

}
  • 练习
//由父及子，静态先行
class Root{
	static{
		System.out.println("Root的静态初始化块");
	}
	{
		System.out.println("Root的普通初始化块");
	}
	public Root(){
		System.out.println("Root的无参数的构造器");
	}
}
class Mid extends Root{
	static{
		System.out.println("Mid的静态初始化块");
	}
	{
		System.out.println("Mid的普通初始化块");
	}
	public Mid(){
		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();
	}
}

知识点5：属性赋值

/**
 * 1. 有哪些位置可以给类中的属性赋值？ （以非静态的属性说明）
 * ① 默认初始化
 * ② 显式初始化  / ⑤ 代码块中初始化
 * ③ 构造器中初始化
 *
 * ④ 创建了对象以后，通过"对象.属性"或"对象.方法"的方式给属性赋值
 *
 *
 * 2. 赋值的先后顺序？
 *  ① - ②、⑤ - ③ - ④
 *
 *  说明：② 、 ⑤ 的执行按照声明的位置决定的。先声明的先执行。
 *
 *
 * @author shkstart
 * @create 2020-07-08 15:49
 */
public class OrderTest {
    public static void main(String[] args) {
        Order order =  new Order(2);
        System.out.println(order.orderId);
        System.out.println(order.orderName);
    }
}

class Order{
    int orderId;

    {
        orderId = 1;
        orderName = "order_BB";
    }

    String orderName = "order_AA";

    public Order(int orderId){
        this.orderId = orderId;

    }

}

知识点6：final

/**
 * final关键字的使用
 *
 * 1. final:最终的
 *
 * 2. final可以用来修饰：类、方法、变量
 *
 * 3. final修饰类：表示此类不能被继承。比如：String\StringBuffer\StringBuilder
 *
 * 4. final修饰方法：表示此方法不能被重写。比如：Object类中的getClass()
 *
 * 5.1 final修饰属性（或成员变量）：此属性一旦赋值，就不能修改。--->常量
 *      比如：Math中的PI
 *      >哪些位置可以给final修饰的属性赋值：显式初始化；代码块中赋值；构造器中赋值；
 *
 *      >声明为static final的属性：全局常量
 *
 *  5.2 final修饰局部变量:常量。一旦赋值就不能修改。
 *        > 如果修饰形参的话，则在调用此方法时，给形参的常量赋值即可。
 *
 * @author shkstart
 * @create 2020-07-08 16:26
 */
public class FinalTest {

    final int MY_NUM1 = 0;

    final int NUM2 ;

    final int NUM3;

//    final int NUM4;

    {
        NUM2 = 1;
    }

    public FinalTest(){
//        NUM2 = 3;
        NUM3 = 2;
    }

    public FinalTest(String info){
        this();
    }

//    public void setNUM4(int num){
//        this.NUM4 = num;
//    }
//
//    public static void main(String[] args) {
//        FinalTest test = new FinalTest();
//
//
//        test.setNUM4(10);
//    }

    public void method(){
        final int num;
        num = 1;
//        num++;

        System.out.println(num);
    }

    public void method1(final int num){
//        num++;
    }

}





//class MyString extends String{
//
//}

//final class A{
//
//}
//class B extends A{
//
//}

class C{
    public void method(){

    }
}

class D extends C{
//    public void method(){
//
//    }
}
  • 说明：我们在开发时，主要考虑final修饰属性、形参时，需要的话，要及时加上final。

课后练习

包装类的练习

package com.atguigu.homework;

import java.util.Scanner;
import java.util.Vector;

/**
 * 利用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等
 *
 * @author shkstart
 * @create 2020-07-08 9:37
 */
public class ScoreTest {
    public static void main(String[] args) {
        //1. 实例化Vector对象，用于存放学生成绩
        Vector v = new Vector();
        //2. 实例化Scanner对象，便于从键盘获取学生成绩
        Scanner scanner = new Scanner(System.in);
        //定义最高分的变量
        int maxScore = 0;
        //3. 根据提示，通过循环从键盘获取学生成绩，并保存在Vector中
        for(;;){
            System.out.print("请输入学生成绩：");
            int score = scanner.nextInt();
            //判断退出的条件
            if(score < 0){
                break;
            }

//            v.addElement(new Integer(score));//jdk5.0之前
            v.addElement(score);//jdk5.0之后：自动装箱
            //4. 获取学生的最高分
            if(maxScore < score){
                maxScore = score;
            }
        }

        //5. 遍历学生成绩，获取各个学生的成绩和等级
        for(int i = 0;i < v.size();i++){
           int score = (int) v.elementAt(i);
           char grade;
           if(maxScore - score <= 10){
               grade = 'A';
           }else if (maxScore - score <= 20){
               grade = 'B';
           }else if(maxScore - score <= 30){
               grade = 'C';
           }else{
               grade = 'D';
           }
            System.out.println("学生" + i + "成绩为：" + score + ",等级为：" + grade);
        }

    }
}
猛肝自然强
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
201771010106东文财《面向对象程序设计（java）》第四章学习总结
deman0710的博客
09-26 161
实验四类与对象的定义及使用 实验时间 2018-9-20 第一部分：理论知识学习部分 1.类 类(class)是具有相同属性和行为的一组对象的集合，是构造程序的基本单元，是构造对象的模板或蓝图。 2.对象 对象：即数据，对象有三个特性——1.行为 2.状态 3.标识。 3.类与对象的关系 （1）类是对象，事物的描述和抽象，是具有相同属性和行为的对象集合。对象则是该类事物的...
面向对象接口
weixin_30618985的博客
05-08 121
一、 接口的基础知识 1、为什么需要接口 为解决实际应用中，单一继承无法解决的问题 2、什么是接口 a) 基本概念？ 接口是一种特殊的抽象类 接口是一种规范和标准，可以约束类的行为，是一些方法特征集合，但方法没有方法体 b) 基本语法 访问修饰符 interface 接口名{ //定义 方法（没有方法体），方法的访问修...
Java面向对象程序设计 第四章总结
HAYIKI
10-06 251
问题目录1. 对象与对象引用的区别是什么？请举例说明2. 对象作为参数传递的特点是什么？请举例说明3. 对象初始化顺序是怎么样的？请举例说明4. 类的static字段与非static字段的区别是什么？什么情况应该使用static修饰符？请举例说明5. Java中final修饰符都有什么作用？请举例说明6. Java中float[10] arr；语句正确吗？为什么？7. Java数组元素类型为基本数据类型和引用类型时，有什么不同？请举例说明 1. 对象与对象引用的区别是什么？请举例说明 2. 对象作为参.
201771010113 李婷华 《面向java对象程序设计（Java）》第四章学习总结
weixin_30642305的博客
09-25 140
一.理论知识部分 第四章对象与类 本章主要讲述面向对象程序设计、如何创建标准Java类库中的类对象、如何编写自己的类。 1.面向对象程序设计的几个主要概念： 抽象数据类型、类和对象、封装、类层次（子类）、继承性、多态性。 2.类：具有相同属性和行为的一组对象的集合。 3.实例域：对象中的数据。 4.方法：操纵数据的过程。 5.对象的三个主要特性： 对象的行为、对象的状态、对象...
Java OOP 面向对象编程 第四章笔记
Chun1999的博客
07-09 128
接口 interface 制定了某种规则，一种统一规范。 USB 全球统一 type-c 插线板 class Door{ public void open(){ } public void close(){ } } class FdDoor extends Door{ } class Lock{ public void open(){} public void close(){} } 如何让防盗门同时具备门
2021年JAVA学习笔记.doc
12-16
"2021年JAVA学习笔记" 本篇笔记涵盖了Java的基础知识点，从Java的开发环境到面向对象编程的概念。下面是对笔记内容的详细解释： 一、Java开发环境 * JDK（Java Develop Kit）：Java开发工具包 * JRE（Java ...
java从入门到精通-学习笔记整理863页.doc
06-10
Java 从入门到精通学习笔记整理 本资源摘要信息中，我们将从 Java 的基本概念到高级开发技术进行详细的介绍，涵盖了 Java 平台、Java 开发平台、Java 程序的运行机制、Java 编程语言的特点、Java 语言的基本语法、...
2021Java零基础自学笔记资源（九）
09-10
Java语言的面向对象性体现在它支持对象oriented编程。Java语言的可移植性体现在它可以在多种平台上运行。 五、Java语言的加载与执行过程 Java语言的加载与执行过程包括以下几个步骤：编写Java源代码、编译Java源...
Java/JavaEE 学习笔记
03-20
Core Java学习笔记...........31 第一章 JAVA前言..31 第二章 标识符，关键字，类型........35 第三章 表达式与流控制....................41 第四章 数组.............50 第五章 对象和类（OO思想）.........53 第...
java各知识点详细总结(毕向东笔记整理)
01-30
第一章：编程基础 3-11 第二章：数组 11 -31 第三章：面向对象程序开发 31 -74 第四章：异常机制 74 -89 第五章：多线程技术 89 -122122122 第六章：常用类 API 122API 122 API 122API 122API 122API 122API 122-...
JAVA面向对象编程(孙卫琴)读书笔记（四）
偶成長的點滴
09-21 168
一个java源文件 包含了一个或零个包声明语句 package 包含了零个或多个引入语句 import 包含零个或多个类的声明  class 包含零个多个接口的声明 interface   （但是最多只有一个类或者是接口为public 且源文件的名字要 和声明为public 的类和接口一致）   包的命名 例如：com.abc.netstore.common.SysContent类 从上面这个类所...
Java基础学习笔记：第四章（四）面向对象编程
LastYHM的博客
07-06 201
知识点1：子类对象实例化的过程 * 1. 从结果上来说：体现为类的继承性 * 子类继承父类以后，当创建子类对象时，堆空间中除了会加载子类自己特有的属性之外，还会加载其所有的父类 * 中的属性。当权限允许的情况下，子类对象可以调用父类的属性。 * * 2. 从过程上来看： * 当我们子类构造器创建子类对象时，一定会直接或间接的调用其父类的构造器，乃至于父类的父类的构造器，。。。 * 直到调用了java.lang.Object类的构造器。由于我们加载过子类的所有的父类的构造器，所有，我们在堆空间
Java基础学习笔记：第四章（三）面向对象编程
LastYHM的博客
07-06 214
知识点1：package 和 import关键字的使用 package com.atguigu.java; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.HashMap; import java.util.Map; import java.sql.Date; import java.util.Scanner; import java.util.Map.Entry; import static j
Java笔记第四章 面向对象
qq_41268977的博客
05-19 403
第四章 面向对象 目录第四章 面向对象一、Java面向对象学习的三条主线二、面向过程（POP）与面向对象（OOP）三、Java基本元素：类和对象是面向对象的核心概念四、类的成员之一：属性=成员变量=field=域、字段五、类的成员之二：方法=成员方法=函数=method六、再谈方法七、OOP特征一：封装与隐藏八、类的成员之三：构造器Constructor（任何一个类都有构造器）九、关键字：this十、关键字：package、import十一、OOP特征二：继承性十二、方法的重写（override）十三、四种
Java核心技术卷一第四章读书笔记
GatesMa's blog
07-13 633
文章目录1. 面向对象设计概述2. 使用预定义类3. 用户自定义类4. 静态域与静态方法5. 方法参数6. 对象构造 1. 面向对象设计概述 面向对象程序设计（OOP）是当今主流的程序设计范型 Java是完全面向对象的，必需熟悉Op才能编写Java程序 算法 + 数据结构 = 程序 类是构造对象的模版或蓝图。封装是与对象有关的一个重要概念（实现封装的关键在于绝对不能让类中的方法直接...
编写一个类实现银行账户Account的概念
热门推荐
好奇独角兽
10-11 1万+
编写一个类实现银行账户Account的概念，包含的属性有“帐号”、“密码”、“存款余额”、“利率rate”、“最小余额”，定义封装这些属性的方法。账号要自动生成。编写主类，使用银行账户类，输入、输出3个储户的上述信息。考虑：哪些属性可以设计成static属性。 Account.java public class Account { private int account_number;//账号...
java-java57-第六次作业
chouzipin2534的博客
11-10 187
一、Point类 package org.jsoft.LeiFengZhuang; public class Point { private int x; private int y; public int getX() { return x;...
Java学习心得之static关键字
寒风中的信
10-20 186
一、static关键字简介 含义： 在类中，用static声明成员变量为静态变量，它为该类的公用类。static成员变量只有一份。用static声明方法为静态方法，在调用该方法时，不会将对象的引用传递给他，所以在static方法中不可访问非static方法可以通过对象或类名访问静态成员 静态变量和静态方法是属于类的，所有该类的对象公用静态方法和静态变量。 二、静态成员变量
通过System.out.println() 理解static关键字
DifferentW的博客
10-20 817
static：如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。
java面向对象程序设计第三版耿祥义第一章笔记
最新发布
03-27
Java面向对象程序设计第三版耿祥义第一章主要介绍了Java的基础知识和面向对象的概念。 1. Java语言的特点 Java语言是一种面向对象的编程语言，具有以下特点： - 简单易学：Java语言的语法类似C++，但是去掉了C++中比较难理解的特性，使得Java更加容易学习和使用。 - 面向对象：Java语言是一种纯面向对象的编程语言，所有的程序都是由对象组成的。 - 平台无关性：Java语言可以在不同的操作系统和硬件平台上运行，只需要安装相应的Java虚拟机即可。 - 安全性：Java语言的安全性非常高，可以在不信任的环境下运行程序，避免了一些安全漏洞。 - 高性能：Java语言的运行速度比较快，且可以通过各种优化技术来提高性能。 2. 面向对象的概念 面向对象是一种软件设计的思想，其核心是将问题看作是由对象组成的。对象是指具有一定属性和行为的实体，属性是对象的特征，行为是对象的动作。 在面向对象的设计中，需要考虑以下几个方面： - 类的设计：类是创建对象的模板，需要定义类的属性和方法。 - 对象的创建：创建对象时，需要使用new关键字来调用类的构造方法。 - 对象的访问：访问对象的属性和方法时，需要使用点号操作符来进行访问。 - 继承和多态：继承是指一个类可以继承另一个类的属性和方法，多态是指同一种行为可以用不同的方式实现。 3. Java的基础知识 Java语言的基础知识包括数据类型、运算符、流程控制语句等。 - 数据类型：Java语言的数据类型包括基本数据类型和引用数据类型。基本数据类型包括整型、浮点型、字符型和布尔型，引用数据类型包括类、接口、数组等。 - 运算符：Java语言的运算符包括算术运算符、关系运算符、逻辑运算符、位运算符等。 - 流程控制语句：Java语言的流程控制语句包括if语句、switch语句、for循环、while循环、do-while循环等。 4. Java程序的基本结构 Java程序的基本结构包括类的定义、方法的定义和语句块的定义。 - 类的定义：类是Java程序的基本组成单元，需要使用class关键字来定义类。 - 方法的定义：方法是类中的一个函数，用于实现特定的功能，需要使用方法名、参数列表和返回值类型来定义方法。 - 语句块的定义：语句块是一组语句的集合，需要使用大括号来定义语句块。 总的来说，Java面向对象程序设计第三版耿祥义第一章介绍了Java语言的基础知识和面向对象的概念，为后续的学习打下了基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值