脚本宝典收集整理的这篇文章主要介绍了Java 面向对象，脚本宝典觉得挺不错的，现在分享给大家，也给大家做个参考。
面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据
抽象
三大特性
从认识论角度考虑是先有对象后有类。对象是具体的事物，类是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板
构造器也称为构造方法，在进行创建对象时必须要调用构造器，特点
构造器作用
构造器分类
public class Application {
public static void main(String[] arg){
// Person person = new Person();
// System.out.println(person.name);
Person person = new Person("Xiaoming");
System.out.println(person.name);
}
}
public class Person {
/*
1.默认构造器
一个类什么也不写仍然会存在一个默认构造器
会在class文件中自动生成一个无参构造器
*/
String name;
/*
2.无参构造器，用于实例初始化
初始化在new完实例后即执行
*/
// public Person(){
// this.name="Xiaoming";
// }
/*
3.使用有参构造器，必须再显示定义一个无参构造器
否则会没有无参构造
*/
public Person(){}
public Person(String name){
this.name=name;
}
}
类与对象
类是一个模板，抽象，对象是一个具体的实例
方法
定义、调用
对应的引用
引用类型：除了8大基本类型外
对象是通过引用来操作的：栈->堆
属性：字段Field 成员变量
默认初始化：
数字：0或0.0
char：u000
boolean：false
引用：null
对象的创建和使用
类：
静态的属性 属性
动态的行为 方法
程序设计要“高内聚，低耦合”，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：近暴露少量的方法给外部使用
封装（数据隐藏）禁止直接访问一个对象中数据的实际表示，通过操作接口访问
使用get/set访问数据，可以在get和set方法中加入属性的合法性检验代码
注意封装一般都是对属性封装私有，方法一般不封装
IDEA中可以使用alt+insert快速生成get、set函数
alt+insert->Getter and setter->选择私有属性
public class Application {
public static void main(String[] arg){
Person person = new Person();
person.setName("Xiaoming");
System.out.println(person.getName());
}
}
public class Person {
//私有属性
private String name;
//提供一些可以操作私有属性的方法 set、get方法
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
}
概念
super与this使用
package com.yang;
public class Application {
public static void main(String[] arg){
Student student = new Student();
student.printName("application");
}
}
//Person类
public class Person {
protected String name="person";
}
//Student类
public class Student extends Person{
private String name="student";
void printName(String name){
System.out.println(name);
System.out.println(this.name);//this调用本类内部属性
System.out.println(super.name);//super调用父类
}
}
super调用构造器
在new对象时，是先调用父类的构造再调用子类构造
super()会调用父类的构造方法，此过程会默认执行，可以不写
this()会调用子类的构造方法，super()和this()都必须在子类构造方法的第一个，因此不能同时出现
super()默认调用的是父类的无参构造，当父类没有无参构造时就会报错
当父类没有无参构造时可以使用super(参数)调用父类有参构造
public class Application {
public static void main(String[] arg){
Student student = new Student();//在new对象时，是先调用父类的构造再调用子类构造
}
}
//父类
public class Person {
public Person() {
System.out.println("父类的无参构造");
}
}
//子类
public class Student extends Person{
public Student() {
//super();//super()会调用父类的构造方法，此过程会默认执行，可以不写
System.out.println("子类的无参构造");
}
}
方法的重写(属性没有重写)
public class Application {
public static void main(String[] arg){
//静态方法调用只和左边定义的数据类型有关
//静态方法不存在重写
B b = new B();
b.test();
A a = new B();
a.test();
}
}
//父类
public class A {
//使用静态方法
public static void test(){
System.out.println("A->test");
}
}
//子类
public class B extends A{
使用静态方法
public static void test(){
System.out.println("B->test");
}
}
public class Application {
public static void main(String[] arg){
B b = new B();
b.test();
A a = new B();
a.test();
}
}
public class A {
public void test(){
System.out.println("A->test");
}
}
public class B extends A{
//子类重写了父类的方法
public void test(){
System.out.println("B->test");
}
}
public class Application {
public static void main(String[] arg){
//多态，对象的实际类型确定，但指向的引用类型是不确定的，父类可以指向子类
//对象能调用的方法主要看对象左边的类型，与右边关系不大
//子类可以调用自己或者继承父类的方法
//父类可以指向子类，但是不能调用子类的方法
Person person = new Student();
Student student = new Student();
person.test();
student.test();
}
}
public class Person {
public void test(){
System.out.println("Person_test");
}
}
public class Student extends Person{
@Override
public void test() {
System.out.println("Student_test");
}
}
instanceof判断一个对象与于另一个类之间是否有关系
如Teacher类和Student类都继承Person类
Person person=new Student；
判断对象person和Teacher类是否有关联
instanceof判断过程
首先判断左边引用类型person和Teacher是否有关系，若person和Teacher无关系则编译报错
其次判断右边实例化对象类型Student和Teacher是否有关系，若有关系则返回true，无关则返回false
public class Application {
public static void main(String[] arg){
Person person = new Student();
System.out.println(person instanceof Object);//true
//System.out.println(person instanceof String);//编译报错
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Teacher);//false
}
}
public class Person {
}
public class Student extends Person{
}
public class Teacher extends Person{
}
父子类之间的类型转换
public class Application {
public static void main(String[] arg){
Student student = new Student();
Person person=student;//向上转换直接转
Student student1=(Student) person;//向下转需要强制转换
}
}
public class Student extends Person{
public void test(){}
}
public class Person {
//构造函数
public Person(){
System.out.println("构造方法执行");
}
//匿名代码块
{
System.out.println("匿名代码块执行");
}
//静态代码块
static {
System.out.println("静态代码块执行");
}
public static void main(String[] args){
Person person = new Person();
System.out.println("==============");
Person person1 = new Person();//静态代码块将不再执行
}
}
静态导入包
import java.lang.Math;
public class Application {
public static void main(String[] arg){
System.out.println(Math.PI);//不使用静态导入需要使用Math.*调用方法
}
}
//使用static关键字静态导入包
import static java.lang.Math.PI;
public class Application {
public static void main(String[] arg){
System.out.println(PI);//静态导入不需要再使用Math.PI
}
}
public class Application {
public static void main(String[] args) {
//Action action=new Action();//抽象类不能被new
A a=new A();
a.test();
}
}
//使用abstract声明抽象类
public abstract class Action {
//使用abstract声明抽象方法
public abstract void test();
}
public class A extends Action {
//继承抽象类必须重写抽象方法
@Override
public void test() {
System.out.println("抽象类测试");
}
}
普通类：只有具体实现
抽象类：既有具体实现，又有规范
接口：只有规范，无法自己写方法
接口是多继承
接口的关键字是interface
接口中定义的方法默认为public abstract，因此接口中定义方法使用
返回值类型 方法名（参数）；
接口中一般不定义属性，如果定义属性，则均默认为常量public static final
接口需要重实现，实现使用关键字implements
//UserService接口定义
//接口关键字interface
public interface UserService {
//接口中定义都是抽象的public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
//TimeService接口定义
public interface TimeService {
void timer();
}
//多继承同时实现UserService和TimeService
//接口实现关键字implements
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
内部类就是在一个类内部再定义一个类
成员内部类
静态内部类
局部内部类
匿名内部类
以上是脚本宝典为你收集整理的Java 面向对象全部内容，希望文章能够帮你解决Java 面向对象所遇到的问题。
本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。