Java基础(3)-面向对象

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java基础(3)-面向对象，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11742字，纯文字阅读大概需要17分钟。

内容图文

写于2019.5.16

参考：java1234

以对象的思维去分析和解决问题

访问控制权限、package、import

访问权限

权限修饰词	类内	包内	子类	全局
Private	Yes	No	No	No
Package	Yes	Yes	No	No
Pretected	Yes	Yes	Yes	No
Public	Yes	Yes	Yes	Yes

注：Package为缺省的访问权限

package

用来归纳分类
便于项目开发维护
例子：com.java1234.chap01.sec05

import
导入包

内部类和代码块

内部类

在类的内部定义的类
可以方便的使用外部类的属性
破坏了类的基本结构
使用内部类：

/**
 * 外部类
 */
public class Outer {

    private int a=1;
    /**
     * 内部类
     */
    class Inner {
        public void show(){
            System.out.println("调用内部类的show");
            System.out.println(a);
        }
    }

    public void show() {

        Inner inner = new Inner();
        System.out.println("调用外部类的show");
        inner.show();
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

输出

调用外部类的show
调用内部类的show
1

代码块

普通代码块：写在方法里面

public class Demo01 {
    public static void main(String[] args) {
        int a =1;
        {
            a=2;
            System.out.println("普通代码块");
        }
        System.out.println("a="+a);

    }
}

构造代码块
- 每次使用new实例化对象时都执行一次
- 形式：{}

静态代码块

只在第一次使用类，由JVM加载类时执行一次
形式：static {}

public class Demo02 {
  /**
   * 构造块:只执行一次，在加载类的时候执行
   */
  {
      System.out.println("通用构造块");
  }

  /**
   * 静态代码块:对象初始化的时候执行
   */
  static{
      System.out.println("静态代码块");
  }
  public Demo02(){
      System.out.println("构造方法一");
  }

  public Demo02(int i){
      System.out.println("构造方法二");
  }

  public Demo02(int i, int j){
      System.out.println("构造方法三");
  }

  public static void main(String[] args) {
      Demo02 demo02_1 = new Demo02();
      Demo02 demo02_2 = new Demo02(1);
      Demo02 demo02_3 = new Demo02(1,2);
  }
}

输出

静态代码块
通用构造块
构造方法一
通用构造块
构造方法二
通用构造块
构造方法三

String类

两种比较

形式	功能
==	比较引用的位置是否相同
equals()	比较各自引用对象的内容

public class Demo01 {
    public static void main(String[] args) {
        String name1 = "张三";
        String name2 = new String("张三");
        String name3 = name2; // 传递引用

        // 比较引用
        System.out.println("name1==name2 " + (name1==name2));
        System.out.println("name1==name3 " + (name1==name3));
        System.out.println("name2==name3 " + (name2==name3));

        // equals比较内容
        System.out.println("name1.equals(name2) " + name1.equals(name2));
        System.out.println("name1.equals(name3) " + name1.equals(name3));
        System.out.println("name2.equals(name3) " + name2.equals(name3));
    }
}

输出

name1==name2 false
name1==name3 false
name2==name3 true
name1.equals(name2) true
name1.equals(name3) true
name2.equals(name3) true

两种实例化方法的区别

String name1="张三"：如果字符串常量池中已存在"张三"，则直接引用；否则创建新的字符串
String name1=new String("张三")：无论字符串是否存在，都创建新的字符串

public class Demo02 {
    public static void main(String[] args) {
        String name1 = "张三";
        String name2 = "张三";

        String name3 = new String("张三");
        String name4 = new String("张三");

        System.out.println("name1==name2 "+(name1==name2));
        System.out.println("name1==name3 "+(name1==name3));
        System.out.println("name3==name4 "+(name3==name4));
    }
}

输出

name1==name2 true
name1==name3 false
name3==name4 false

String的内容不可修改
常用方法

方法	描述
charAt()	返回指定索引位置的字符
length()	返回字符串长度
indexOf()	返回与指定字符匹配的第一个字符索引
subString()	返回指定索引范围内的字符构成的字符串
toUpperCase()	将字符串中的小写字母转成大写
toLowerCase	将字符串中的大写字母转成小写
trim()	去除字符串首尾的空格

具体参考：JDK_API_1_6_zh_CN

public class Demo04 {
    public static void main(String[] args) {
        String name = "张三";
        char ming = name.charAt(1);
        System.out.println(ming);

        String str = "我是中国人";
        for(int i=0; i<str.length(); i++){
            System.out.println(str.charAt(i));
        }
    }
}

public class Demo05 {
    public static void main(String[] args) {
        String str = "sgadhakjkdjalddass";
        System.out.println("d在字符串str中第一次出现的索引位置是"+str.indexOf('d'));
        System.out.println("d在字符串str中第一次出现的索引位置，从索引5位置开始 "+str.indexOf('d',5));
    }
}

public class Demo06 {
    public static void main(String[] args) {
        String str = "不开心每一天";
        String str2 = "不开心每一天不可能";
        System.out.println(str.substring(1));
        System.out.println(str.substring(1,6));

    }
}

public class Demo07 {
    public static void main(String[] args) {
        String str = "I'm a boy!";
        System.out.println(str.toUpperCase());
        System.out.println(str.toLowerCase());
    }
}

public class Demo08 {
    public static void main(String[] args) {
        String str = "  aB232 23 & &*( s2 ";
        // 去掉前后空格
        String newStr = str.trim();
        System.out.println("原始字符串："+str);
        System.out.println("去掉前后空格："+newStr);
        int letterCount = 0;
        int spaceCount = 0;
        int digitCount = 0;
        int otherCount = 0;
        for(int i=0; i<newStr.length(); i++){
            char c = newStr.charAt(i);
            if(c>='a' && c<='z' || c>='A' && c<='Z')
                letterCount++;
            else if(c==' ')
                spaceCount++;
            else  if(c>='0' && c<='9')
                digitCount++;
            else
                otherCount++;
        }
        System.out.println("英文字符数："+letterCount);
        System.out.println("空格字符数："+spaceCount);
        System.out.println("数字字符数："+digitCount);
        System.out.println("其它字符数："+otherCount);
    }
}

继承

java只能单继承
私有方法不能继承
对象实例化过程和super关键字
- super：调用父类的属性或方法，super()

final关键字和抽象类

final

终结，完结

用法	描述
final修饰类名	该类不可被继承
final修饰方法	该方法不可被重写
final修饰变量	该变量内容初始化后不可被修改，作为常量使用

/**
 * 僵尸类
 */
public final class Jiangshi {

}

public class People {
    private final int a=1;
    public void action() {
        System.out.println("做一个良好的公民");
    }
}

抽象类

含有一个抽象方法的类称为抽象类
至少含有一个抽象方法
抽象类和抽象方法都需要使用abstract关键字修饰
抽象类必须被子类（普通类）重写抽象方法
抽象类不能被实例化

public abstract class People {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void say() {
        System.out.println("我的名字叫"+name);
    }

    public abstract void profession();
}

public class Teacher extends People {
    @Override
    public void profession() {
        System.out.println("我的职业是老师");
    }
}

public class Student extends People {
    @Override
    public void profession() {
        System.out.println("我的职业是学生");
    }
}

public class Test {
    public static void main(String[] args) {
//        People people = new People(); // 报错，抽象类不能被实例化
        Student student = new Student();
        Teacher teacher = new Teacher();
        student.profession();
        teacher.profession();
    }
}

接口

没有普通方法。与抽象方法和全局常量组成
接口必须被实现
一个类可以实现多个接口
同时继承类和实现接口：先继承类，后实现接口

public interface A {
    /**
     * 全局常量
     */
    public static final String TITLE = "www.java1234.com";

    /**
     * 抽象方法：abstarct可以省略
     */
    public void a();
}

public interface B {
    /**
     * 全局常量
     */
    public static final String TITLE2 = "Java知识分享网";

    /**
     * 抽象方法：abstarct可以省略
     */
    public void b();
}

public class C {
    public void c() {
        System.out.println("c方法");
    }
}

public class Test extends C implements A,B { // 必须先继承，后实现接口
    @Override
    public void a() {
        System.out.println("a方法");
    }

    @Override
    public void b() {
        System.out.println("b方法");
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.a();
        test.b();
        System.out.println(Test.TITLE);
        System.out.println(Test.TITLE2);
    }
}

输出

a方法
b方法
www.java1234.com
Java知识分享网

多态性

表现

方法的重载与重写
可以用父类指向子类的具体实现，调用方法时，如果子类中重载或重写了该方法，则自动调用子类的方法，否则调用父类方法；
父类随时可以归还为其它子类的具体实现

public class Animal {
  public void say() {
      System.out.println("我是一个动物");
  }
}

public class Dog extends Animal{
  @Override
  public void say() {
      System.out.println("我是一只狗");
  }
}

public class Cat extends Animal {
  @Override
  public void say() {
      System.out.println("我是一只猫");
  }
}

public class Test {
  public static void main(String[] args) {
      // 父类引用指向Dog子类的具体实现
      Animal animal = new Dog();
      animal.say();

      // 随时更换实现
      /*animal = new Cat();
      animal.say();*/

      Dog dog = (Dog)animal;
      dog.say();

      /*Cat cat = (Cat)animal; // 运行抛出异常
      cat.say();*/
  }
}

转型
- 向上转型：子类类型转到父类，安全
- 向下转型：父类类型转到子类，不安全，可能抛出运行异常

public interface People {
    public void say();
}

public class Student implements People{
    @Override
    public void say() {
        System.out.println("我是学生");
    }
}

public class Teacher implements People {
    @Override
    public void say() {
        System.out.println("我是老师");
    }
}

public class Test2 {
    public static void main(String[] args) {
        People p1 = new Student();
        p1.say();

        p1 = new Teacher();
        p1.say();

        Student student = (Student) p1; // 运行抛出异常
        student.say();
    }
}

Object类

所有的Java类都继承自Object类
toString()
equals()

public class People {
    private String name;

    public People(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name;
    }

    @Override
    public boolean equals(Object obj) {
        String name=((People)obj).getName();
        return this.name.equals(name);
    }

    public static void main(String[] args) {
        People p1 = new People("张三");
        People p2 = new People("李四");
        System.out.println(p1);
        System.out.println(p1.toString());

        People p3 = new People(new String("李四"));
        System.out.println(p1.equals(p2));
        System.out.println(p2.equals(p3));
    }
}

输出

张三
张三
false
true

instancesof关键字

判断一个对象是否属于一个类
形式：对象 instancesof 类型，返回boolean类型
可以用于向下转型时判断对象类型

public class Animal {
    public void say(){
        System.out.println("我是一个动物");
    }
}

public class Dog extends Animal{
    @Override
    public void say(){
        System.out.println("我是一只狗");
    }

    public void f1(){
        System.out.println("汪汪");
    }
}

public class Cat extends Animal{
    @Override
    public void say(){
        System.out.println("我是一只猫");
    }
    public void f2(){
        System.out.println("我喜欢吃鱼");
    }
}

public class Test {
    public static void doSomething(Animal animal){
        animal.say();
        if(animal instanceof Dog) { // 向下转型判断类别
            ((Dog)animal).f1();
        }else{
            ((Cat)animal).f2();
        }

    }

    public static void main(String[] args) {
        Animal animal = new Dog();
        System.out.println("dog对象是否属于Animal类："+(animal instanceof Animal));
        System.out.println("dog对象是否属于Dog类："+(animal instanceof Dog));
        System.out.println("dog对象是否属于Cat类："+(animal instanceof Cat));

        doSomething(new Dog());
        doSomething(new Cat());
    }
}

输出

dog对象是否属于Animal类：true
dog对象是否属于Dog类：true
dog对象是否属于Cat类：false
我是一只狗
汪汪
我是一只猫
我喜欢吃鱼

匿名内部类

没有名字，只有实例化

public interface A {
    public void say();
}

public class B implements A{
    @Override
    public void say() {
        System.out.println("B类实现a方法");
    }
}

public class Test {
    public void test(A a){
        a.say();
    }

    public static void main(String[] args) {
        Test t = new Test();
        t.test(new B());

        t.test(new A() {
            @Override
            public void say() {
                System.out.println("匿名内部类，一次性使用");
            }
        });
    }
}

输出

B类实现a方法
匿名内部类，一次性使用

包装类

每个基本类型都对应一个包装类
装箱和拆箱
- 装箱：基本类型转换成类
- 拆箱：包装类转换成基本类型

public class Demo01 {
    public static void main(String[] args) {
        int a=1;
        Integer i = new Integer(a); // 装箱
        int b = i.intValue(); //拆箱

        System.out.println("a="+a);
        System.out.println("i="+i);
        System.out.println("b="+b);
    }
}

装箱和拆箱过程是自动进行的

public class Demo02 {
    public static void main(String[] args) {
        Integer i=1; //自动装箱的过程，自动把基本类型转换成类类型
        int i2=i;   // 自动拆箱的过程，自动把类类型转换成基本类型
        System.out.println("i="+i);
        System.out.println("i2="+i2);
    }
}

public class Demo03 {
    public static void main(String[] args) {
        String a="3";
        String b="5";
        int c = Integer.valueOf(a)+Integer.valueOf(b);
        System.out.println("c="+c);
    }
}

设计模式

参考《Head First 设计模式》
单例模式：懒汉式和饿汉式

/**
 * 饿汉式
 */
public class Singleton {
    /**
     * 构造方法私有
     */
    private Singleton(){

    }
    public static final Singleton single=new Singleton();

    /**
     * 获取实例
     * @return
     */
    public static Singleton getInstance(){
        return single;
    }
}

/**
 * 懒汉式
 */
public class Singleton2 {
    /**
     * 构造方法私有
     */
    private Singleton2(){

    }
    public static Singleton2 single=null;

    /**
     * 获取实例
     * @return
     */
    public synchronized static Singleton2 getInstance(){
        if(single==null){
            single=new Singleton2();
            System.out.println("第一次调用");
        }
        return single;
    }
}

内容总结

以上是互联网集市为您收集整理的Java基础(3)-面向对象全部内容，希望文章能够帮你解决Java基础(3)-面向对象所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/826590.html

来源：【匿名】

【上一篇】Java基本元素【下一篇】JAVA/JSP学习系列之五

更多 ►

【Java基础(3)-面向对象】教程文章相关的互联网学习教程文章

Java平台有3个版本：适用于小型设备和智能卡的JavaME（Java Platform Micro Edition，Java微型版）、适用于桌面系统的JavaSE（Java Platform Standard Edition，Java标准版）和适用于企业级应用的JavaEE（Java Platform Enterprise Edition）。而JavaEE是一个开发企业级应用的规范和标准，在现在的企业级开发中最为常用，最受开发者的青睐。　　参考资料JavaEE的相关技术原文：https://www.cnblogs.com/WJQ2017/p/8401382.html

Java基础面试题集（二）

Java程序员面试题集（1-50）一、Java基础部分1、面向对象的特征有哪些方面?答：面向对象的特征主要有以下几个方面：1)抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。2)继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。3)封装：通常认...

java基础学习（四）【代码】

java基础学习（四）十二、包装类十三、Object类十四、System类十五、数组十二、包装类序号基本数据类型包装类1byteByte2shortShort3intInteger4longLong5charCharacter6floatFloat7doubleDouble8booleanBoolean2.Integer类常用方法：方法返回值功能byteValue()byte以 byte 类型返回该 Integer 的值shortValue()short以 short 类型返回该 Integer 的值intValue()int以 int 类型返回该 Integer 的值toString()String返回一个表示该...

java基础——集合【代码】【图】

集合与数组的区别： 1.数组是固定长度的；集合的长度是可变的。 2.数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。 3.数组存储元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。 java集合主要有3种重要的类型： ●List：是一个有序集合，可以存放重复的数据。 ●Set: 是一个无序集合，不允许存放重复的数据。 ●Map: 是一个无序集合，集合中包含一个键对象和一个值对象，键对象不...

Java基础四【图】

Java基础四一、Switch语句二、if和switch区别推荐使用if 三、函数Java中的函数和方法是同一个词四、数组4.1、数组常见错误五、内存机制六、转换成十六进制移位&操作6.2 查表法求十六进制查表法很多时候都非常好用，这样就非常好了，真的非常好用算的时候直接移四位，我喜欢，我觉得以后可以多做移位运算，真的是简单方便 6.3 查表法求星期几原文：http://www.cnblogs.com/Renyi-Fan/p/6883048.html

java基础（十三）常用类总结（三）【代码】

这里有我之前上课总结的一些知识点以及代码大部分是老师讲的笔记个人认为是非常好的，，也是比较经典的内容，真诚的希望这些对于那些想学习的人有所帮助！由于代码是分模块的上传非常的不便。也比较多，讲的也是比较清晰的！如果你有需要可以在评论中留下您的邮箱我看到一定会免费发给你的！感谢这个平台让我们大家共同进步吧！！记住程序员是无私的！！！也非常欢迎到我的博客内观看博客地址：http://www.cnblogs.com/duscl/ ...

Java基本基础【图】

之前学习了.net，感觉还好，不过发现了几句话很有含义：有的女人就是Windows虽然很优秀，但是安全隐患太大。有的女人就是MFC她条件很好，然而不是谁都能玩的起。有的女人就是C#长的很漂亮，但是家务活不行。有的女人就是C++,她会默默的为你做很多的事情。有的女人就是汇编虽然很麻烦，但是有的时候还得求它。有的女人就是SQL，她会为你的发展带来莫大的帮助。不过现在是学Java了，今天通过学习了Java的，简单的描述java语法：...

java基础——String和StringBuffer的区别

首先在java中有三个类来操作字符串：Character 是进行单个字符操作的;String 对一串字符进行操作。不可变类;StringBuffer 也是对一串字符进行操作，但是可变类String:是对象不是原始类型.为不可变对象,一旦被创建,就不能修改它的值.对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.String 是final类,即不能被继承.StringBuffer:是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象它只...

Java基础之绑定

绑定绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。对java来说，绑定分为静态绑定和动态绑定；或者叫做前期绑定和后期绑定. 静态绑定在程序执行前方法已经被绑定（也就是说在编译过程中就已经知道这个方法到底是哪个类中的方法），此时由编译器或其它连接程序实现。例如：Ｃ。针对java简单的可以理解为程序编译期的绑定；这里特别说明一点，java当中的方法只有final，static，private和构造方法是前期绑定动态绑定 ...

Java_Day05 Java基础

1. 抽象类和一般类的区别 : 1) 抽象类使用 abstract 修饰 2) 抽象类不能被实例化 3) 抽象类中可以有抽象方法,也可以没有抽象方法2. - 使用 interface 声明 - 接口是抽象方法和常量的集合, 不能再有其他任何成分 - 接口中的方法默认修饰为 public abstract - 接口中常量的默认修饰为 public static final - 实现接口使用 implements 关键字 - 一个类可以实现多个接口, 多个接口之间使用逗号分隔 - 接口之间...

【Java基础】类型转换【代码】【图】

1publicclass Demo2 {2publicstaticvoid main(String[] args) {3//byte/short/char->int->long->float->double4// 低->高5//运算中，不同类型的数据要先转换成同一类型，再进行运算。 6int i = 128;7byte b = (byte)i; //存在内存溢出的问题高->低 8double d = i;// 低->高 9 System.out.println(i); 10 System.out.println(b); 1112//强制转换（类型）变量名高->低 13//自动转换低->高1415/*16 注...

java基础面试题

1.什么是Java虚拟机?为什么Java被称作是“平台无关的编程语言”?Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。Java被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独重写或者是重新编译。Java虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特性。 2.JDK和JRE的区别是什么?Java运行时环境(JRE)是将要执行Java程序的Java虚拟机。它...

Think in Java(一)：Java基础

一. OOP的特点(1) 万物皆为对象; (2) 程序是对象的集合，他们通过发送信息来告诉彼此所要做的; (3) 每一个对象都有自己的由其它对象所构成的存储; (4) 每一个对象都拥有它的类型; (5) 某一特定类型的对象都能够接收相同的消息;二. Java比C++简单?(1) Java有垃圾回收器, 不用手动销毁对象; (2) Java使用单根继承; (3) Java仅仅能以一种方式创建对象(在堆上创建);三. 数据存储 (1) 寄存器: 速度最快, 数量有限, 它位于CPU内部, 但我们...

Java基础Day3【代码】【图】

Java基础第三天Java基础第三天1.1赋值运算符符号： = （1）当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。 (2)支持连续赋值。扩展赋值运算符： +=, -=, *=, /=, %= 思考1： short s = 3; s=s+2; ① s+=2; ② ①和②有什么区别？扩展赋值运算符不改变数据类型思考2：boolean b1 = false; //区分好==和=的区别。 if(b1=true)System.out.printl...

java基础第六章课后习题【图】

1.说明循环结构中break语句和continue语句的区别。在循环结构中 break语句是结束程序运行。 continue语句是结束本句程序不是结束程序。2.使用for循环结构实现，从键盘上接受从周一至周五每天学习时间，并计算每日平均学习时间。输出结果。3.鸡兔同笼问题。今有鸡兔同笼，上有35头，下有94足，问鸡兔各几只？试编写程序解决问题。4.开发一个标题为“ FlipFlop”的游戏应用程序。它从 1 计数到100 ，遇到3的倍数输出单词“ Flip...

首页 / JAVA / Java基础(3)-面向对象

Java基础(3)-面向对象

内容导读

内容图文

访问控制权限、package、import

内部类和代码块

String类

继承

final关键字和抽象类

接口

多态性

Object类

instancesof关键字

匿名内部类

包装类

设计模式

内容总结

内容备注

内容手机端

【Java基础(3)-面向对象】教程文章相关的互联网学习教程文章

Java 基础 Java平台的3个版本

Java基础面试题集（二）

java基础学习（四）【代码】

java基础——集合【代码】【图】

Java基础四【图】

java基础（十三）常用类总结（三）【代码】

Java基本基础【图】

java基础——String和StringBuffer的区别

Java基础之绑定

Java_Day05 Java基础

【Java基础】类型转换【代码】【图】

java基础面试题

Think in Java(一)：Java基础

Java基础Day3【代码】【图】

java基础第六章课后习题【图】

JAVA - 相关标签

面向对象 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程